From 7c13caaf85c41cf8db2f6952af92709fdb6d4701 Mon Sep 17 00:00:00 2001
From: songdawei <songdawei1@huawei.com>
Date: Fri, 25 Mar 2022 03:59:17 +0000
Subject: [PATCH] =?UTF-8?q?=E6=84=8F=E8=A7=81=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: songdawei <songdawei1@huawei.com>
---
 common/shm_utils.cpp                          |   38 +-
 common/shm_utils.h                            |   14 +-
 .../disdata_func_test.cpp                     | 1145 +++++++----------
 .../process_common/process_msg.cpp            |   80 +-
 .../process_common/process_msg.h              |   22 +-
 5 files changed, 518 insertions(+), 781 deletions(-)

diff --git a/common/shm_utils.cpp b/common/shm_utils.cpp
index 143f05c..29d0e15 100644
--- a/common/shm_utils.cpp
+++ b/common/shm_utils.cpp
@@ -14,34 +14,34 @@
  */
 
 #include "shm_utils.h"
-#include <string.h>
 #include <cstring>
 using namespace std;
 
-#define PERMISSION 0666
-#define CODE_HEAD 4
-#define STR_KEY 5
-#define CODE_LEN 5
-#define SHARED_DATA_LEN 5
-#define WAITTIME 2
-#define DECIM_TEN 10
-#define CALCU_TWO 2
+const int PERMISSION = 0666;
+const int CODE_HEAD = 4;
+const int STR_KEY = 5;
+const int CODE_LEN = 5;
+const int SHARED_DATA_LEN = 5;
+const int WAITTIME = 2;
+const int DECIM_TEN = 10;
+const int CALCU_TWO = 2;
+const int CALCU_FOUR_AIGHT = 48;
 
-static void *shm = NULL; //分配的共享内存的原始首地址
+static void *shm = nullptr; //分配的共享内存的原始首地址
 static struct shared_use_st *shared; //指向shm
 static int shmid; //共享内存标识符
 
 int createShm(int key)
 {
     //创建共享内存
-    shmid = shmget((key_t)key,sizeof(struct shared_use_st),PERMISSION|IPC_CREAT);
+    shmid = shmget(static_cast(key_t)key, sizeof(struct shared_use_st), PERMISSION|IPC_CREAT);
     if(shmid == -1)
     {
         return -1;
     }
     //将共享内存连接到当前进程的地址空间
-    shm = shmat(shmid,NULL,0);
-    if(shm == (void*)-1)
+    shm = shmat(shmid,nullptr,0);
+    if(shm == reinterpret_cast(void*)-1)
     {
         return -1;
     }
@@ -54,7 +54,7 @@ int createShm(int key)
 void initShm(void)
 {
     memset_s(shm, sizeof(struct shared_use_st), 0, sizeof(struct shared_use_st));
-    if(shared == NULL)
+    if (shared == nullptr)
     {
         return;
     }
@@ -70,7 +70,7 @@ int readDataFromShm(char* buf)
         return -1;
     }
 
-    if(shared->written !=0)
+    if (shared->written !=0)
     {
         strcpy_s(buf , strlen(shared->data)+1, shared->data);
         shared->written = 0;
@@ -99,9 +99,9 @@ int waitDataWithCode(char* code, char* data)
     {
         if(readDataFromShm(str) ==0)
         {
-            if(strncmp(code, str, CODE_HEAD) == 0)
+            if (strncmp(code, str, CODE_HEAD) == 0)
             {
-                strncpy(data,str+STR_KEY,1);
+                strncpy(data, str+STR_KEY, 1);
                 return 0;
             }
 
@@ -192,7 +192,7 @@ char* Int2String(int num,char *str)//10进制
     //转换
     do
     {
-        str[i++] = num%DECIM_TEN+48;
+        str[i++] = num%DECIM_TEN+CALCU_FOUR_AIGHT;
         num /=DECIM_TEN;
     }while(num);//num不为0继续循环
 
@@ -206,7 +206,7 @@ char* Int2String(int num,char *str)//10进制
         ++i;//由于有负号，所以交换的对称轴也要后移一位
     }
     //对称交换
-    for(;j<i/CALCU_TWO;j++)
+    for (; j<i/CALCU_TWO; j++)
     {
         //对称交换两端的值 其实就是省下中间变量交换a+b的值：a=a+b;b=a-b;a=a-b;
         str[j] = str[j] + str[i-1-j];
diff --git a/common/shm_utils.h b/common/shm_utils.h
index 84583fd..2172949 100644
--- a/common/shm_utils.h
+++ b/common/shm_utils.h
@@ -16,18 +16,18 @@
 #ifndef SHM_UTILS_H
 #define SHM_UTILS_H
 
-#include <errno.h>
+#include <cerrno>
 #include <securec.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include <cstdio>
+#include <cstdlib>
 #include <unistd.h>
-#include <stdint.h>
-#include <stdarg.h>
+#include <cstdint>
+#include <cstdarg>
 #include <pthread.h>
 #include <sys/time.h>
 #include <sys/shm.h>
 
-#define MAX_DATA_LENGTH      1024
+const int MAX_DATA_LENGTH =1024;
 #define MAX_WAIT_TIMEOUT      10
 #define SHM_SEND_KEY              123456
 #define SHM_RECV_KEY              123466
@@ -60,4 +60,4 @@ char* Int2String(int num,char *str);
 void initShm(void);
 int readDataFromShm(char* buf);
 
-#endif
+#endif
\ No newline at end of file
diff --git a/distributeddatamgr/distributed_kv_store/disdata_func_test.cpp b/distributeddatamgr/distributed_kv_store/disdata_func_test.cpp
index d162150..3be54e2 100644
--- a/distributeddatamgr/distributed_kv_store/disdata_func_test.cpp
+++ b/distributeddatamgr/distributed_kv_store/disdata_func_test.cpp
@@ -27,7 +27,7 @@
 #include<vector>
 #include<iterator>
 #include <unistd.h>
-#include <string.h>
+#include <cstring>
 #include <cstring>
 typedef enum{
     CTRL_CODE_SOFTBUS_TYPE = 1000,
@@ -47,8 +47,10 @@ typedef enum{
     CTRL_CODE_RESULT_TYPE = 9999,
 } CtrlCodeType;
 
-#define MAX_DATA_LENGTH 1024
-#define DEFDELTA 0.00001
+const int MAX_DATA_LENGTH = 1024;
+const int DEFDELTA = 0.00001;
+const int ERRNOT_OK = 0;
+
 using namespace testing::ext;
 using namespace OHOS::DistributedKv;
 namespace {
@@ -108,7 +110,7 @@ void DistributedKvDataManagerTest::SetUpTestCase(void)
 
 void DistributedKvDataManagerTest::TearDownTestCase(void)
 {
-    //解关联共享内存
+    // 解关联共享内存
     disconnectShm();
 }
 
@@ -127,10 +129,9 @@ void DistributedKvDataManagerTest::SetUp(void)
     };
 
 
-    //1.本地删除数据库
+    // 1.本地删除数据库
     RemoveAllStore(DisKvTest::manager);
-   
-    //2.远端删除数据库
+    // 2.远端删除数据库
     char* str =(char *)malloc(MAX_DATA_LENGTH);
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(str, strlen("")+1,"");
@@ -144,20 +145,20 @@ void DistributedKvDataManagerTest::SetUp(void)
     {
         return ;
     }
-    strcpy_s(code, strlen(str)+1, str);
+    errno_t errRes = strcpy_s(code, strlen(str)+1, str);
+    if (errRes != ERRNOT_OK){
+        return
+    }
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
-
     free(str);
 
-   //1.本地创建数据库
+   // 1.本地创建数据库
     auto deathRecipient = std::make_shared<DeathRecipient>();
     DisKvTest::manager.RegisterKvStoreServiceDeathRecipient(deathRecipient);
-
     DisKvTest::statusGetKvStore = DisKvTest::manager.GetSingleKvStore(options, { DisKvTest::appId }, { DisKvTest::storeIdTest }, DisKvTest::KvStorePtr);
- 
 
-    //2. 远端创建数据库
+    // 2. 远端创建数据库
     str =(char *)malloc(MAX_DATA_LENGTH);
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(str, strlen("")+1,"");
@@ -170,27 +171,23 @@ void DistributedKvDataManagerTest::SetUp(void)
     {
         return ;
     }
-    strcpy_s(code, strlen(str)+1, str);
+    errno_t errRes = strcpy_s(code, strlen(str)+1, str);
+    if (errRes != ERRNOT_OK){
+        return
+    }
     waitDataWithCode(code, str);
     free(str);
-
 }
-
 void DistributedKvDataManagerTest::TearDown(void)
 {}
-
 void DistributedKvDataManagerTest::RemoveAllStore(DistributedKvDataManager manager)
 {
     DisKvTest::statusCloseKvStore = DisKvTest::manager.CloseAllKvStore(DisKvTest::appId);
     DisKvTest::statusDeleteKvStore = DisKvTest::manager.DeleteAllKvStore(DisKvTest::appId);
 }
-
 DistributedKvDataManagerTest::DistributedKvDataManagerTest(void)
 {}
 
-
-
-
 class KvStoreSyncCallbackTestImpl : public KvStoreSyncCallback {
 public:
     void SyncCompleted(const std::map<std::string, Status> &results);
@@ -218,9 +215,7 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     ZLOGI("DistribitedKvDataManager_Sync_Push_0100 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-
-
-    //本地数据库添加数据 100
+    // 本地数据库添加数据 100
     std::string stringKey = "math_score_int";
     Key keyInt = stringKey;
     //int nint = 100;
@@ -228,23 +223,19 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
-
-
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-   
-
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_int:100")+1, "math_score_int:100");
@@ -260,7 +251,7 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     waitDataWithCode(code, str);
     std::cout << "int 100 get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 }
@@ -278,35 +269,29 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
 
-    //////////////////////////////////////////////////////////////////////////////////////////////
-    //本地数据库添加数据 3.14f
+    // 本地数据库添加数据 3.14f
     std::string stringKey = "math_score_float";
     Key keyInt = stringKey;
-    
+
     Value valueInt = Value(TransferTypeToByteArray<float>(3.14f));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
-
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
-
-   
-
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_float:3.14")+1, "math_score_float:3.14");
-
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); //2001:math_score_int:10
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
@@ -314,13 +299,11 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << " float 3.14f get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
-
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
@@ -339,26 +322,20 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     ZLOGI("DistribitedKvDataManager_Sync_Push_0300 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-
-    //////////////////////////////////////////////////////////////////////////////////////////////
-    //本地数据库添加数据 28.288f
+    // 本地数据库添加数据 28.288f
     std::string stringKey = "math_score_double";
     Key keyInt = stringKey;
     Value valueInt = Value(TransferTypeToByteArray<double>(28.288f));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
-
-
-
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -381,7 +358,7 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     waitDataWithCode(code, str);
     std::cout << "<double>(28.288f) get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
@@ -396,36 +373,33 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0400, TestSize.Level1)
  {
-     ZLOGI("DistribitedKvDataManager_Sync_Push_0400 begin.");
+    ZLOGI("DistribitedKvDataManager_Sync_Push_0400 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //本地数据库添加数据 12345678
+
+    // 本地数据库添加数据 12345678
     Key keyInt = "math_score_int64_t";
     Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
-
-
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //数据发送到远端并等待返回结果
+    // 数据发送到远端并等待返回结果
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_int64_t:12345678")+1, "math_score_int64_t:12345678");
-
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); //2001:math_score_int:10
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
@@ -433,17 +407,13 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << " <int64_t>(12345678) get result=" << str<< std::endl;
-
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
- 
- }
+}
 
 
 
@@ -459,30 +429,26 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     ZLOGI("DistribitedKvDataManager_Sync_Push_0500 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-
-    //本地数据库添加数据 28
+    // 本地数据库添加数据 28
     Key keyInt = "math_score_size_t";
     Value valueInt = Value(TransferTypeToByteArray<size_t>(28));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
-
-
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //数据发送到远端并等待返回结果
+    // 数据发送到远端并等待返回结果
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_size_t:28")+1, "math_score_size_t:28");
@@ -499,11 +465,9 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     waitDataWithCode(code, str);
     std::cout << " <size_t>(28) get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-  
  }
 
 
@@ -518,35 +482,31 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     ZLOGI("DistribitedKvDataManager_Sync_Push_0600 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-
-    //本地数据库添加数据string 
+    // 本地数据库添加数据string 
     Key keyInt = "math_score_string";
     Value valueInt = Value(  "{\"class\":20, \"age\":18, \"gradle\":\"good\"}"  );
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
-
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //数据发送到远端并等待返回结果
+    // 数据发送到远端并等待返回结果
     char str[MAX_DATA_LENGTH] ={"math_score_string:{\"class\":20, \"age\":18, \"gradle\":\"good\"}"};
     //strcpy_s(str, strlen("math_score_int:d")+1, "math_score_int:d");
 
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, str); //2001:math_score_int:10
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {0};
     Int2String(CTRL_CODE_RESULT_TYPE, str);
@@ -557,11 +517,9 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     waitDataWithCode(code, str);
     std::cout << "string get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-  
  }
 
 
@@ -577,10 +535,7 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     ZLOGI("DistribitedKvDataManager_Sync_Push_0700 begin.");    
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-
-    //1.///////////////////////////////////////////////////////////////////////////////////////////////////////
-    //本地数据库添加数据 vector<int>
+    // 本地数据库添加数据 vector<int>
     std::string stringKey = "math_score_vector";
     Key keyInt = stringKey;
     std::vector<uint8_t> vect = {0,1,2,3,4,5,6,7};
@@ -588,26 +543,23 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     Status status = DisKvTest::KvStorePtr->Put(keyInt,valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //同步数据到远端
+    // 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
-
-
     status =DisKvTest:: KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-   usleep(USLEEP_TIME);
+    usleep(USLEEP_TIME);
 
-    //数据发送到远端并等待返回结果
-    //std::vector<uint8_t> vect = {0,1,2,3,4,5,6,0};
-	std::string strvc;
+    // 数据发送到远端并等待返回结果
+    std::string strvc;
     strvc.assign(vect.begin(), vect.end());
 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int"};
@@ -631,11 +583,9 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     waitDataWithCode(code, str);
     std::cout << "vector<int> get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-
  }
 
 
@@ -648,32 +598,31 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0100, TestSize.Level1)
  {
     ZLOGI("DistribitedKvDataManager_Sync_Pull_0100 begin."); 
-   //1.本端创建KV
+    // 1.本端创建KV
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
 
-    //2.创建远端KV
-    //3. 本地数据库添加数据 100 
+    // 2.创建远端KV
+    // 3. 本地数据库添加数据 100 
     Key keyInt = "math_score_int";
     Value valueInt = Value(TransferTypeToByteArray<int>(100));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据200
-    
+    // 5.远端修改数据200
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_int:200")+1, "math_score_int:200");
@@ -691,17 +640,17 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     waitDataWithCode(code, str);
     std::cout  << " put-200  get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-   //6.本地pull远端数据
+   // 6.本地pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL); //PUSH_PULL
@@ -719,10 +668,7 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-
-
-
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -730,34 +676,30 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     EXPECT_EQ(status, Status::SUCCESS);
     int aaa = TransferByteArrayToType<int>(valueRetInt.Data());
     EXPECT_EQ( aaa, 200);
- 
 
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
+
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
+
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << " get-200 get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
 
  }
 
- 
 /**
  *  @tc.number: DistribitedKvDataManager_Sync_Pull_0200
  *  @tc.name: remote put data, local sync pull
@@ -766,42 +708,36 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0200, TestSize.Level1)
  {
-     ZLOGI("DistribitedKvDataManager_Sync_Pull_0200 begin."); 
+    ZLOGI("DistribitedKvDataManager_Sync_Pull_0200 begin."); 
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     std::string stringKey = "math_score_float";
     Key keyInt = stringKey;
-    
     Value valueInt = Value(TransferTypeToByteArray<float>(3.14f));
 
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据200
-  
-
+    // 5.远端修改数据200
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_float:9.99")+1, "math_score_float:9.99");
-
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
-
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {0};
@@ -809,26 +745,21 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout <<  "put-9.99 get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-
-    //6.本地pull远端数据
-       
+    // 6.本地pull远端数据
     remoteDevice.clear();  
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-
-   
     deviceList.clear();  
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
@@ -846,10 +777,8 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::SUCCESS);
@@ -857,28 +786,22 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     float delta = aaa - 9.99f;
     EXPECT_LE(std::abs(delta), DEFDELTA);
 
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout <<  "get-9.99 get result=" << str<< std::endl;
-
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-   
  }
 
 
@@ -892,36 +815,29 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
  {
     ZLOGI("DistribitedKvDataManager_Sync_Pull_0300 begin."); 
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
-    ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据28.288f
+    ASSERT_NE(nullptr, DisKvTest::KvStorePtr)<<"KvStorePtr is nullptr";
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据28.288f
     std::string stringKey = "math_score_double";
     Key keyInt = stringKey;
     Value valueInt = Value(TransferTypeToByteArray<double>(28.288));
 
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
-
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据 
-
+    // 5.远端修改数据 
     char strKV[MAX_DATA_LENGTH] = {"math_score_double:999.999"};
-   // memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
-    //strcpy_s(strKV, strlen("math_score_double:999.999")+1, "math_score_double:999.999");
-
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
@@ -934,23 +850,18 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout <<  "put double get result=" << str<< std::endl;
-
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //6.本地pull远端数据
-    
+    // 6.本地pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-
-   
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
     EXPECT_EQ(status, Status::SUCCESS); 
 
@@ -966,9 +877,8 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::SUCCESS);
@@ -978,31 +888,26 @@ void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Stat
     std::cout<<"delta = "<< delta <<std::endl;
     EXPECT_LE(std::abs(delta), DEFDELTA);
 
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout <<  "put double get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-   
  }
 
-
-
-
 /**
  *  @tc.number: DistribitedKvDataManager_Sync_Pull_0400
  *  @tc.name: remote put data, local sync pull
@@ -1014,28 +919,27 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0400,
     ZLOGI("DistribitedKvDataManager_Sync_Pull_0400 begin."); 
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int64_t";
     Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据200
+    // 5.远端修改数据200
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_int64_t:99889988")+1, "math_score_int64_t:99889988");
@@ -1048,27 +952,23 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0400,
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "put-200  get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //6.本地pull远端数据
-    
+    // 6.本地pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-
-   
-   deviceList.clear();
+    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
     EXPECT_EQ(status, Status::SUCCESS);
     auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1082,44 +982,32 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0400,
     {
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
-
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::SUCCESS);
     int64_t aaa = TransferByteArrayToType<int64_t>(valueRetInt.Data());
     EXPECT_EQ( aaa, 99889988u);
 
-
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << "put int64_t get result=" << str<< std::endl;
-
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
-   
  }
 
-
-
 /**
  *  @tc.number: DistribitedKvDataManager_Sync_Pull_0500
  *  @tc.name: remote put data, local sync pull
@@ -1131,32 +1019,30 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0500,
     ZLOGI("DistribitedKvDataManager_Sync_Pull_0100 begin."); 
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_size_t";
     Value valueInt = Value(TransferTypeToByteArray<size_t>(28));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据200
+    // 5.远端修改数据200
     char strKV[MAX_DATA_LENGTH] = {"math"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_size_t:88")+1, "math_score_size_t:88");
-
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
@@ -1164,15 +1050,14 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0500,
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << "size_t get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //6.本地pull远端数据
+    // 6.本地pull远端数据
     //std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -1181,9 +1066,9 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0500,
     //std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }   
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
     EXPECT_EQ(status, Status::SUCCESS);
     auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1198,37 +1083,30 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0500,
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::SUCCESS);
     size_t aaa = TransferByteArrayToType<size_t>(valueRetInt.Data());
     EXPECT_EQ( aaa, 88u);
 
-
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << "get size_t  result=" << str<< std::endl;
-
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
-   
  }
 
 
@@ -1243,28 +1121,28 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0600,
     ZLOGI("DistribitedKvDataManager_Sync_Pull_0600 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_string";
     Value valueInt = Value(  "{\"class\":20, \"age\":18, \"gradle\":\"good\"}"  );
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据200
+    // 5.远端修改数据200
     char strPut[MAX_DATA_LENGTH] = {"math_score_string:{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strPut);
    char str[MAX_DATA_LENGTH] = {0};
@@ -1273,27 +1151,24 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0600,
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << "put string result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //6.本地pull远端数据
-   
+    // 6.本地pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
-   
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;        
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
     EXPECT_EQ(status, Status::SUCCESS);
     auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1308,9 +1183,8 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0600,
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::SUCCESS);
@@ -1319,27 +1193,23 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0600,
     EXPECT_EQ( aaa, sstring);
 
 
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strPut); 
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << "get string  result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-   
  }
 
 
@@ -1354,9 +1224,9 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     ZLOGI("DistribitedKvDataManager_Sync_Pull_0700 begin."); 	
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3.本地数据库添加数据 vector<int>
+
+    // 2.创建远端Lv
+    // 3.本地数据库添加数据 vector<int>
     std::string stringKey = "math_score_vector";
     Key keyInt = stringKey;
     std::vector<uint8_t> vect = {0,1,2,3,4,5,6,7};
@@ -1364,23 +1234,23 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     Status status = DisKvTest::KvStorePtr->Put(keyInt,valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端修改数据200
+    // 5.远端修改数据200
 
     std::vector<uint8_t> vect2 = {9,9,8,8,7,7,6,6};
-	std::string strvc;
+    std::string strvc;
     strvc.assign(vect2.begin(), vect2.end());
 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int"};
@@ -1400,27 +1270,23 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-vector<uint8_t>  get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //6.本地pull远端数据
-    
+    // 6.本地pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
-   
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
     EXPECT_EQ(status, Status::SUCCESS);
     auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1435,7 +1301,7 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据 与200比较
+    // 7.本地get数据 与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -1444,30 +1310,24 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     std::string strValueRet = valueRetInt.ToString();
     EXPECT_EQ( strvc, strValueRet.c_str());
 
-
-    //8.数据发送到远端并等待返回结果
+    // 8.数据发送到远端并等待返回结果
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
     ASSERT_NE(nullptr, str);
     strcpy_s(code, strlen(str)+1, str);  // 9999
-   
+
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout << "put vector<uint8_t> get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
-
  }
 
 /**
@@ -1481,31 +1341,29 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0100 begin."); 	
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int";
     Value valueInt = Value(TransferTypeToByteArray<int>(100));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端delete 数据
+    // 5.远端delete 数据
     char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
-    
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {0};
@@ -1515,22 +1373,20 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << " delete int result=" << str<< std::endl;
-    
+
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //6.本地push_pull远端数据
-    
+    // 6.本地push_pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
-    
     deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
     EXPECT_EQ(status, Status::SUCCESS);
    auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1545,17 +1401,16 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
+    // 7.本地get数据失败
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::KEY_NOT_FOUND);
 
-    //8.远端get数据失败
+    // 8.远端get数据失败
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
+
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
@@ -1565,15 +1420,13 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     waitDataWithCode(code, str);
     std::cout  << " get int  result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"1");
     EXPECT_EQ(ret, 0);
 
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
-
  }
 
 
@@ -1586,36 +1439,32 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0200, TestSize.Level1)
  {
-    
     ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0200 begin.");
- 
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int";
     Value valueInt = Value(TransferTypeToByteArray<float>(3.14f));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端delete 数据
+    // 5.远端delete 数据
     char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
-    
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {0};
@@ -1625,21 +1474,18 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << " delete float get result=" << str<< std::endl;
-    
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //6.本地push_pull远端数据
-    
+    // 6.本地push_pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-    
     deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }       
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
     EXPECT_EQ(status, Status::SUCCESS);
     auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1654,18 +1500,14 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
+    // 7.本地get数据失败
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::KEY_NOT_FOUND);
 
-
-    //8.远端get数据失败
+    // 8.远端get数据失败
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
@@ -1675,11 +1517,11 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     waitDataWithCode(code, str);
     std::cout  << " get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"1");
     EXPECT_EQ(ret, 0);
 
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
 
@@ -1694,33 +1536,32 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0300, TestSize.Level1)
  {
-    
+
     ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0300 begin.");
-    
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int";
     Value valueInt = Value(TransferTypeToByteArray<double>(28.288f));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端delete 数据
+    // 5.远端delete 数据
     char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
     char str[MAX_DATA_LENGTH] = {0};
@@ -1732,132 +1573,22 @@ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700,
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "delete double result=" << str<< std::endl;
-    
+
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //6.本地push_pull远端数据
+    // 6.本地push_pull远端数据
     
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
-    
     deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
-
-    status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
-    EXPECT_EQ(status, Status::SUCCESS);
-auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
-    status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
-    EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
-    if(status == Status::SUCCESS)
-    {
-        std::cout<<"LOGdisDataTest--SUCCESS: register sync callback"<< std::endl;
-    }
-    else
-    {
-        std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
-    usleep(USLEEP_TIME);
-
-
-    Value valueRetInt;
-    status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
-    EXPECT_EQ(status, Status::KEY_NOT_FOUND);
-
-
-    //8.远端get数据失败
-    writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
-    memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
-    memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
-    Int2String(CTRL_CODE_RESULT_TYPE, str);
-    ASSERT_NE(nullptr, str);
-    strcpy_s(code, strlen(str)+1, str);  // 9999
-    memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
-    waitDataWithCode(code, str);
-    std::cout  << "get result=" << str<< std::endl;
-
-    //检查远端是否返回成功
-    ret = strcmp(str,"1");
-    EXPECT_EQ(ret, 0);
-
-    //解注册回调
-    status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
-    EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
- }
-
-
-/**
- *  @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0400
- *  @tc.name: remote delete data, local sync push_pull
- *  @tc.desc: sync push_pull ,delete int64_t data 
- *  @tc.type: FUNC
-*/
- HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0400, TestSize.Level1)
- {
-    
-    ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0400 begin.");
-   
-    EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
-    ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
-    Key keyInt = "math_score_int";
-    Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
-    Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
-    EXPECT_EQ(Status::SUCCESS, status);
-
-    //4. sync push 同步数据到远端
-    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
-    status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
-    EXPECT_EQ(status, Status::SUCCESS);
-
-    std::vector<std::string> deviceList;
-    for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
-        deviceList.push_back(device.deviceId);
-    }
-    status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
-    ASSERT_EQ(status, Status::SUCCESS);
-
-    //5.远端delete 数据
-    char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
-    writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
-    char str[MAX_DATA_LENGTH] = {0};
-    memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
-    char code[CODE_LEN_TEN] = {0};
-    Int2String(CTRL_CODE_RESULT_TYPE, str);
-    ASSERT_NE(nullptr, str);
-    strcpy_s(code, strlen(str)+1, str);  // 9999
-    memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
-    waitDataWithCode(code, str);
-    std::cout  << " delete int64_t result=" << str<< std::endl;
-    
-    int ret = strcmp(str,"0");
-    EXPECT_EQ(ret, 0);
-
-    //6.本地push_pull远端数据
-    
-    remoteDevice.clear();
-    status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
-    EXPECT_EQ(status, Status::SUCCESS);
-
-   
-   deviceList.clear();
-    for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
-        deviceList.push_back(device2.deviceId);
-    }       
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
     EXPECT_EQ(status, Status::SUCCESS);
     auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1872,17 +1603,111 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
+    // 7.本地get数据失败
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::KEY_NOT_FOUND);
 
-    //8.远端get数据失败
+    // 8.远端get数据失败
+    writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
+    memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
+    memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
+    Int2String(CTRL_CODE_RESULT_TYPE, str);
+    ASSERT_NE(nullptr, str);
+    strcpy_s(code, strlen(str)+1, str);  // 9999
+    memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
+    waitDataWithCode(code, str);
+    std::cout  << "get result=" << str<< std::endl;
+
+    // 检查远端是否返回成功
+    ret = strcmp(str,"1");
+    EXPECT_EQ(ret, 0);
+
+    // 解注册回调
+    status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
+    EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
+
+ }
+
+
+/**
+ *  @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0400
+ *  @tc.name: remote delete data, local sync push_pull
+ *  @tc.desc: sync push_pull ,delete int64_t data 
+ *  @tc.type: FUNC
+*/
+ HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0400, TestSize.Level1)
+ {
+    ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0400 begin.");
+    EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
+    ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
+    Key keyInt = "math_score_int";
+    Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
+    Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
+    EXPECT_EQ(Status::SUCCESS, status);
+
+    // 4. sync push 同步数据到远端
+    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
+    status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
+    EXPECT_EQ(status, Status::SUCCESS);
+
+    std::vector<std::string> deviceList;
+    for (const auto& device : remoteDevice) {
+        std::cout << "start sync" << device.deviceId << std::endl; 
+        deviceList.push_back(device.deviceId);
+    }
+    status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
+    ASSERT_EQ(status, Status::SUCCESS);
+
+    // 5.远端delete 数据
+    char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
+    writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
+    char str[MAX_DATA_LENGTH] = {0};
+    memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
+    char code[CODE_LEN_TEN] = {0};
+    Int2String(CTRL_CODE_RESULT_TYPE, str);
+    ASSERT_NE(nullptr, str);
+    strcpy_s(code, strlen(str)+1, str);  // 9999
+    memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
+    waitDataWithCode(code, str);
+    std::cout  << " delete int64_t result=" << str<< std::endl;
+
+    int ret = strcmp(str,"0");
+    EXPECT_EQ(ret, 0);
+
+    // 6.本地push_pull远端数据
+    remoteDevice.clear();
+    status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
+    EXPECT_EQ(status, Status::SUCCESS);
+    deviceList.clear();
+    for (const auto& device2 : remoteDevice) {
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
+        deviceList.push_back(device2.deviceId);
+    }
+    status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
+    EXPECT_EQ(status, Status::SUCCESS);
+    auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
+    status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
+    EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
+    if(status == Status::SUCCESS)
+    {
+        std::cout<<"LOGdisDataTest--SUCCESS: register sync callback"<< std::endl;
+    }
+    else
+    {
+        std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
+    }
+
+    // 7.本地get数据失败
+    usleep(USLEEP_TIME);
+    Value valueRetInt;
+    status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
+    EXPECT_EQ(status, Status::KEY_NOT_FOUND);
+    // 8.远端get数据失败
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
@@ -1892,16 +1717,14 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     waitDataWithCode(code, str);
     std::cout  << "get  result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"1");
     EXPECT_EQ(ret, 0);
 
-   //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
-
- }
+}
 
 
 /**
@@ -1912,36 +1735,32 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0500, TestSize.Level1)
  {
-    
     ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0500 begin.");
-  
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int";
     Value valueInt = Value(TransferTypeToByteArray<size_t>(28));
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端delete 数据
+    // 5.远端delete 数据
     char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
-    
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {0};
@@ -1951,23 +1770,19 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << " delete size_t result=" << str<< std::endl;
-    
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-
-    //6.本地push_pull远端数据
-   
+    // 6.本地push_pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
-   
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }       
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
     EXPECT_EQ(status, Status::SUCCESS);
 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
@@ -1982,16 +1797,15 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
+    // 7.本地get数据失败
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::KEY_NOT_FOUND);
 
-     //8.远端get数据失败
+     // 8.远端get数据失败
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
@@ -2001,14 +1815,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     waitDataWithCode(code, str);
     std::cout  << " get  result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"1");
     EXPECT_EQ(ret, 0);
 
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
  }
 
 
@@ -2020,36 +1833,32 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0600, TestSize.Level1)
  {
-    
     ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0600 begin.");
-   
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-	
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int";
     Value valueInt = Value(  "{\"class\":20, \"age\":18, \"gradle\":\"good\"}"  );
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端delete 数据
+    // 5.远端delete 数据
     char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
-    
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {0};
@@ -2059,25 +1868,22 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "delete string result=" << str<< std::endl;
-    
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-
-    //6.本地push_pull远端数据
-       
+    // 6.本地push_pull远端数据
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
 
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
     EXPECT_EQ(status, Status::SUCCESS);
-auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
+    auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
     EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
     if(status == Status::SUCCESS)
@@ -2089,17 +1895,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
+    // 7.本地get数据失败
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::KEY_NOT_FOUND);
-
-   //8.远端get数据失败
+   // 8.远端get数据失败
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
-    
-    
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
     Int2String(CTRL_CODE_RESULT_TYPE, str);
@@ -2109,14 +1911,12 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     waitDataWithCode(code, str);
     std::cout  << " get result=" << str<< std::endl;
 
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"1");
     EXPECT_EQ(ret, 0);
-
-    //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
  }
 
 
@@ -2128,35 +1928,33 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */
  HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0700, TestSize.Level1)
  {
-    
+
     ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0700 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //2.创建远端Lv
-    //3. 本地数据库添加数据 100
+    // 2.创建远端Lv
+    // 3. 本地数据库添加数据 100
     Key keyInt = "math_score_int";
     std::vector<uint8_t> vect = {0,1,2,3,4,5,6,7};
     Value valueInt = Value( vect );
     Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
     EXPECT_EQ(Status::SUCCESS, status);
 
-    //4. sync push 同步数据到远端
+    // 4. sync push 同步数据到远端
     std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-
     std::vector<std::string> deviceList;
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync" << device.deviceId << std::endl;        
+        std::cout << "start sync" << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
     ASSERT_EQ(status, Status::SUCCESS);
 
-    //5.远端delete 数据
+    // 5.远端delete 数据
     char strKV[MAX_DATA_LENGTH] = {"math_score_int:100"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
-    
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {"9999"};
@@ -2166,7 +1964,6 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << " delete vector result=" << str<< std::endl;
-    
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
@@ -2174,15 +1971,14 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     remoteDevice.clear();
     status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
     EXPECT_EQ(status, Status::SUCCESS);
-   
    deviceList.clear();
     for (const auto& device2 : remoteDevice) {
-        std::cout<<"start sync"<<device2.deviceId<<std::endl;       
+        std::cout<<"start sync"<<device2.deviceId<<std::endl;
         deviceList.push_back(device2.deviceId);
-    }    
+    }
     status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
     EXPECT_EQ(status, Status::SUCCESS);
-auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
+    auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
     EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
     if(status == Status::SUCCESS)
@@ -2194,14 +1990,12 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
         std::cout<<"LOGdisDataTest--FAIL: register sync callback"<< static_cast<int>(status) << std::endl;
     }
 
-    //7.本地get数据失败
+    // 7.本地get数据失败
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::KEY_NOT_FOUND);
-
-    //8.远端get数据失败
+    // 8.远端get数据失败
     writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); 
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     memset_s(code, CODE_LEN_TEN, 0, CODE_LEN_TEN);
@@ -2211,21 +2005,14 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << " get result=" << str<< std::endl;
-
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     ret = strcmp(str,"1");
     EXPECT_EQ(ret, 0);
-
-  //解注册回调
+    // 解注册回调
     status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
     EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
-
  }
 
-
-
-
-
 /**
  *  @tc.number: SubscribeWithQuery_0100
  *  @tc.name: SubscribeWithQuery 
@@ -2234,20 +2021,16 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0100, TestSize.Level1)
  {
-    
     ZLOGI("SubscribeWithQuery_0100 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
-
-    //3. 远端put int 
-    
+    // 1.本端创建Lv
+    // 2.远端创建kv
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     strcpy_s(strKV, strlen("math_score_int:200")+1, "math_score_int:200");
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
-
     char str[MAX_DATA_LENGTH] = {0};
     memset_s(str,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
     char code[CODE_LEN_TEN] = {"9999"};
@@ -2258,11 +2041,10 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
-
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2271,19 +2053,16 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
-
     DataQuery dataQuery;
     dataQuery.KeyPrefix("math");
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     Key keyInt = "math_score_int";
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
@@ -2291,16 +2070,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     int aaa = TransferByteArrayToType<int>(valueRetInt.Data());
     std::cout<< "LOGdisDataTest--本地get数据与200比较: aaa = " <<aaa << std::endl;
     EXPECT_EQ( aaa, 200);
-
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
 
  }
 
 
-
-
 /**
  *  @tc.number: SubscribeWithQuery_0200
  *  @tc.name: SubscribeWithQuery
@@ -2309,14 +2085,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0200, TestSize.Level1)
  {
-    
     ZLOGI("SubscribeWithQuery_0200 begin.");
    EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_float:9.99"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2330,11 +2105,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2343,7 +2118,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2352,8 +2127,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -2364,8 +2138,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     float aaa = TransferByteArrayToType<float>(valueRetInt.Data());
     float delta = aaa - 9.99f;
     EXPECT_LE(std::abs(delta), DEFDELTA);
-
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
 
@@ -2380,14 +2153,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0300, TestSize.Level1)
  {
-    
     ZLOGI("SubscribeWithQuery_0300 begin.");
    EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_double:999.999"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2401,11 +2173,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2414,7 +2186,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2423,8 +2195,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -2438,13 +2209,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::cout<<"delta = "<< delta <<std::endl;
     EXPECT_LE(std::abs(delta), DEFDELTA);
 
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
 
  }
- 
-
 
 /**
  *  @tc.number: SubscribeWithQuery_0400
@@ -2454,14 +2223,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0400, TestSize.Level1)
  {
-    
     ZLOGI("SubscribeWithQuery_0400 begin.");
    EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int64_t:99889988"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2475,11 +2243,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2488,7 +2256,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2497,8 +2265,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Key keyInt = "math_score_int64_t";
@@ -2508,15 +2275,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     int64_t aaa = TransferByteArrayToType<int64_t>(valueRetInt.Data());
     EXPECT_EQ( aaa, 99889988u);
 
-
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
 
  }
- 
 
- 
+
 /**
  *  @tc.number: SubscribeWithQuery_0500
  *  @tc.name: SubscribeWithQuery
@@ -2525,14 +2290,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0500, TestSize.Level1)
  {
-    
     ZLOGI("SubscribeWithQuery_0500 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_size_t:88"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2546,11 +2310,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2559,7 +2323,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2568,8 +2332,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Key keyInt = "math_score_size_t";
@@ -2578,9 +2341,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     EXPECT_EQ(status, Status::SUCCESS);
     size_t aaa = TransferByteArrayToType<size_t>(valueRetInt.Data());
     EXPECT_EQ( aaa, 88u);
-
-
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
 
@@ -2595,14 +2356,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0600, TestSize.Level1)
  {
-    
     ZLOGI("SubscribeWithQuery_0600 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_string:{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2616,11 +2376,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2629,7 +2389,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2637,9 +2397,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     dataQuery.KeyPrefix("math");
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
-
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Key keyInt = "math_score_string";
@@ -2649,9 +2407,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::string aaa = valueRetInt.ToString();
     std::string sstring = "{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}";
     EXPECT_EQ( aaa, sstring);
-
-
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
 
@@ -2669,16 +2425,16 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     ZLOGI("SubscribeWithQuery_0700 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
 
     std::string stringKey = "math_score_vector";
     Key keyInt = stringKey;
 
     std::vector<uint8_t> vect2 = {9,9,8,8,7,7,6,6};
-	std::string strvc;
+    std::string strvc;
     strvc.assign(vect2.begin(), vect2.end());
 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int"};
@@ -2702,11 +2458,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-vector<uint8_t>  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SubscribeWithQuery
+    // 4. 本段sync远端数据 SubscribeWithQuery
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2715,7 +2471,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2723,9 +2479,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     dataQuery.KeyPrefix("math");
     auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
-
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -2734,7 +2488,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::string strValueRet = valueRetInt.ToString();
     EXPECT_EQ( strvc, strValueRet.c_str());
 
-    //////取消订阅
+    // 取消订阅
     auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
     EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) <<"LOGdisDataTest--ERR:SubscribeWithQuery";
  }
@@ -2748,14 +2502,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0100, TestSize.Level1)
  {
-    
     ZLOGI("SyncWithCondition_0100 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     
     char strKV[MAX_DATA_LENGTH] = {"math_score_int"};
     memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
@@ -2772,11 +2525,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2785,7 +2538,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
    deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2794,8 +2547,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -2806,7 +2558,6 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::cout<< "LOGdisDataTest--本地get数据与200比较: aaa = " <<aaa << std::endl;
     EXPECT_EQ( aaa, 200);
 
- 
  }
 
 
@@ -2819,14 +2570,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0200, TestSize.Level1)
  {
-    
     ZLOGI("SyncWithCondition_0200 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_float:9.99"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2840,11 +2590,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2853,7 +2603,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2861,9 +2611,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     dataQuery.KeyPrefix("math");
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
-
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -2876,7 +2624,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     EXPECT_LE(std::abs(delta), DEFDELTA);
  }
 
- 
+
 /**
  *  @tc.number: SyncWithCondition_0300
  *  @tc.name: SyncWithCondition
@@ -2889,10 +2637,10 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     ZLOGI("SyncWithCondition_0300 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_double:999.999"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2906,11 +2654,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2919,7 +2667,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2928,8 +2676,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Value valueRetInt;
@@ -2954,14 +2701,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0400, TestSize.Level1)
  {
-    
     ZLOGI("SyncWithCondition_0400 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int64_t:99889988"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -2975,11 +2721,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -2988,7 +2734,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -2997,8 +2743,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Key keyInt = "math_score_int64_t";
@@ -3020,14 +2765,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0500, TestSize.Level1)
  {
-    
     ZLOGI("SyncWithCondition_0500 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_size_t:88"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -3041,11 +2785,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -3054,7 +2798,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -3063,8 +2807,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
 
     Key keyInt = "math_score_size_t";
@@ -3085,14 +2828,13 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
 */ 
  HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0600, TestSize.Level1)
  {
-    
     ZLOGI("SyncWithCondition_0600 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
     char strKV[MAX_DATA_LENGTH] = {"math_score_string:{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}"};
     writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
 
@@ -3106,11 +2848,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -3119,7 +2861,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -3128,10 +2870,8 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
 
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
-
     Key keyInt = "math_score_string";
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
@@ -3154,15 +2894,15 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     ZLOGI("SyncWithCondition_0700 begin.");
     EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
     ASSERT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
-    //1.本端创建Lv
-    //2.远端创建kv
+    // 1.本端创建Lv
+    // 2.远端创建kv
 
-    //3. 远端put int 
+    // 3. 远端put int 
    std::string stringKey = "math_score_vector";
     Key keyInt = stringKey;
 
     std::vector<uint8_t> vect2 = {9,9,8,8,7,7,6,6};
-	std::string strvc;
+    std::string strvc;
     strvc.assign(vect2.begin(), vect2.end());
 
     char strKV[MAX_DATA_LENGTH] = {"math_score_int"};
@@ -3186,11 +2926,11 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     memset_s(str,MAX_DATA_LENGTH, 0,MAX_DATA_LENGTH);
     waitDataWithCode(code, str);
     std::cout  << "yput-200  get result=" << str<< std::endl;
-    //检查远端是否返回成功
+    // 检查远端是否返回成功
     int ret = strcmp(str,"0");
     EXPECT_EQ(ret, 0);
 
-    //4. 本段sync远端数据 SyncWithCondition
+    // 4. 本段sync远端数据 SyncWithCondition
    std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
     remoteDevice.clear();
     Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
@@ -3199,7 +2939,7 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     std::vector<std::string> deviceList;
     deviceList.clear();
     for (const auto& device : remoteDevice) {
-        std::cout << "start sync deviceId = " << device.deviceId << std::endl;        
+        std::cout << "start sync deviceId = " << device.deviceId << std::endl; 
         deviceList.push_back(device.deviceId);
     }
 
@@ -3207,11 +2947,8 @@ auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
     dataQuery.KeyPrefix("math");
     auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
     EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
-
- 
-    //5.本地get数据与200比较
+    // 5.本地get数据与200比较
     usleep(USLEEP_TIME);
-
     Value valueRetInt;
     status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
     EXPECT_EQ(status, Status::SUCCESS);
diff --git a/distributeddatamgr/process_common/process_msg.cpp b/distributeddatamgr/process_common/process_msg.cpp
index b3a567e..e99925e 100644
--- a/distributeddatamgr/process_common/process_msg.cpp
+++ b/distributeddatamgr/process_common/process_msg.cpp
@@ -14,26 +14,26 @@
  */
 
 #include "process_msg.h"
-#include <stdlib.h>
-#include <stdio.h>
+#include <cstdlib>
+#include <cstdio>
 #include <cstdint>
 #include <iostream>
 #include "types.h"
 #include "distributed_kv_data_manager.h"
-#include "string.h"
+#include "cstring"
 #include<sstream> // 使用stringstream
-#include <string.h>
+#include <cstring>
 #include <cstring>
 #include <securec.h>
 using namespace OHOS::DistributedKv;
 using namespace std;
 
-#define DEFDELTA 0.00001
-#define MAX_DATA_LENGTH 1024
-#define NUMTHREE 3
-#define STR_VALUE 23
-#define RESULR_TWO 2
-#define CODE_LEN_TEN 10
+const int DEFDELTA = 0.00001;
+const int MAX_DATA_LENGTH = 1024;
+const int NUMTHREE = 3;
+const int STR_VALUE = 23;
+const int RESULR_TWO = 2;
+const int CODE_LEN_TEN = 10;
 
 class DisKvTest {
 public:
@@ -49,7 +49,7 @@ public:
 };
 
 DistributedKvDataManager DisKvTest::manager;
-std::shared_ptr<SingleKvStore> DisKvTest::KvStorePtr = NULL; // declare kvstore instance.
+std::shared_ptr<SingleKvStore> DisKvTest::KvStorePtr = nullptr; // declare kvstore instance.
 Status DisKvTest::statusGetKvStore = Status::ERROR;
 Status DisKvTest::statusCloseKvStore = Status::ERROR;
 Status DisKvTest::statusDeleteKvStore = Status::ERROR;
@@ -57,13 +57,13 @@ UserId DisKvTest::userId;
 AppId DisKvTest::appId;
 StoreId DisKvTest::storeIdTest;
 
-void initKvstoreId()
+void initKvstoreId(void)
 {
    DisKvTest::userId.userId = "account0";
     DisKvTest::appId.appId = "com.ohos.kvdatamanager3.test";
     DisKvTest::storeIdTest.storeId = "test3";
 
-    //1.创建数据库
+    // 1.创建数据库
     Options options {
         .createIfMissing = true,
             .encrypt = false,     //   .persistant = true,
@@ -79,15 +79,15 @@ void initKvstoreId()
 
 char* getRealData(char* str, char* delims)
 {
-    if(str==NULL || delims==NULL)
+    if(str==nullptr || delims==nullptr)
     {
-        return NULL;
+        return nullptr;
     }
     char *result = strtok( str, delims );
-    char *second = NULL;
-    while( result != NULL ) {
+    char *second = nullptr;
+    while( result != nullptr ) {
       second = result;
-        result = strtok( NULL,delims );
+        result = strtok( nullptr,delims );
     }
     return second;
 }
@@ -96,7 +96,7 @@ void getParam(char* putData, char ret[] [MAX_DATA_LENGTH])
 {
     char str[MAX_DATA_LENGTH] = {":"};
     memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
-    if (putData == NULL)
+    if (putData == nullptr)
     {
         return;
     }
@@ -104,12 +104,12 @@ void getParam(char* putData, char ret[] [MAX_DATA_LENGTH])
     char delims[2] = {":"};
     char *result = strtok( str, delims );
     int i = 0;
-    while( result != NULL ) {
+    while( result != nullptr ) {
         printf( "result is \"%s\"\n", result);
         strcpy_s(ret[i], strlen(result)+1, result);
-        result = strtok( NULL, delims );
+        result = strtok( nullptr, delims );
         i++;
-        if(i == NUMTHREE)
+        if (i == NUMTHREE)
         {
             return;
         }
@@ -129,9 +129,9 @@ int ProcessDataMgr(int code, char* recvData)
     LOG("ProcessDataMgr, begin");
 
     initKvstoreId();
-    if (DisKvTest::KvStorePtr == NULL)
+    if (DisKvTest::KvStorePtr == nullptr)
     {
-        std::cout << "ERR：DisKvTest::KvStorePtr == NULL"<< std::endl;
+        std::cout << "ERR：DisKvTest::KvStorePtr == nullptr"<< std::endl;
         return RESULT_ERR; 
     }
     std::cout << "create status=" << static_cast<int>(DisKvTest::statusGetKvStore) << std::endl;
@@ -186,7 +186,7 @@ int processDeletetData(char* putData)
     char result[NUMTHREE][MAX_DATA_LENGTH] = {{0}, {0}, {0}};
     memset_s(result, NUMTHREE*MAX_DATA_LENGTH, 0, NUMTHREE*MAX_DATA_LENGTH);
     getParam(putData, result);
-    for(int i=0; i<NUMTHREE; i++)
+    for (int i=0; i<NUMTHREE; i++)
     {
         LOG("LOGdisDataTest---processGetData %s", result[i]);
     }
@@ -209,11 +209,11 @@ int processDeletetData(char* putData)
 int processPutData(char* putData)
 {
     LOG("LOGdisDataTest-processPutData,  begin");
-    //解析远端发来的数据 result[0]=code result[1]=key result[RESULR_TWO]=value
+    // 解析远端发来的数据 result[0]=code result[1]=key result[RESULR_TWO]=value
     char result[NUMTHREE][MAX_DATA_LENGTH] = {{0}, {0}, {0}};
     memset_s(result, NUMTHREE*MAX_DATA_LENGTH, 0, NUMTHREE*MAX_DATA_LENGTH);
     getParam(putData, result);
-    for(int i=0; i<NUMTHREE; i++)
+    for (int i=0; i<NUMTHREE; i++)
     {
         LOG("LOGdisDataTest-processPutData %s", result[i]);
     }
@@ -228,12 +228,12 @@ int processPutData(char* putData)
     }
     else  if(strcmp(result[1], "math_score_float") == 0)
     {
-        float f2 = atof(result[RESULR_TWO]); 
+        float f2 = atof(result[RESULR_TWO]);
         valueInt =  Value(TransferTypeToByteArray<float>(f2));
     }
     else  if(strcmp(result[1], "math_score_double") == 0)
     {
-        double f2 = atof(result[RESULR_TWO]); 
+        double f2 = atof(result[RESULR_TWO]);
         valueInt =  Value(TransferTypeToByteArray<double>(f2));
     }
     else  if(strcmp(result[1], "math_score_int64_t") == 0)
@@ -256,8 +256,8 @@ int processPutData(char* putData)
         ss=putData;
         ss2 = ss.substr(STR_VALUE);
         cout<<"LOGdisDataTest2--ss = "<< ss<<endl;
-       cout<<"LOGdisDataTest2--ss2 = "<< ss2<<endl;
-       LOG("LOGdisDataTest2--ss2.c_str() =  %s", ss2.c_str());
+        cout<<"LOGdisDataTest2--ss2 = "<< ss2<<endl;
+        LOG("LOGdisDataTest2--ss2.c_str() =  %s", ss2.c_str());
         valueInt =  Value(ss2);
 
     }
@@ -282,16 +282,16 @@ int processGetData(char* putData)
 {
     LOG("LOGdisDataTest-processGetData,  begin");
 
-    //解析远端发来的数据 result[0]=code result[1]=key result[RESULR_TWO]=value
+    // 解析远端发来的数据 result[0]=code result[1]=key result[RESULR_TWO]=value
     char result[NUMTHREE][MAX_DATA_LENGTH] = {{0}, {0}, {0}};
     memset_s(result, NUMTHREE*MAX_DATA_LENGTH, 0, NUMTHREE*MAX_DATA_LENGTH);
     getParam(putData, result);
-    for(int i=0; i<NUMTHREE; i++)
+    for (int i=0; i<NUMTHREE; i++)
     {
         LOG("for result[i] %s", result[i]);
     }
 
-    //获取到本端数据
+    // 获取到本端数据
     Value valueRetInt;
     Key keyInt=result[1];
     Status status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
@@ -309,7 +309,7 @@ int processGetData(char* putData)
     {
         LOG("LOGdisDataTest--math_score_int ");
         int iaaa = TransferByteArrayToType<int>(valueRetInt.Data());
-        int i2 = atoi(result[RESULR_TWO]); 
+        int i2 = atoi(result[RESULR_TWO]);
         LOG("LOGdisDataTest--iaaa=  %d", iaaa);
         LOG("LOGdisDataTest--i2 =  %d", i2);
         if (iaaa == i2)
@@ -322,7 +322,7 @@ int processGetData(char* putData)
       {
         LOG("LOGdisDataTest--math_score_float ");
         float faaa = TransferByteArrayToType<float>(valueRetInt.Data());
-        float f2 = atof(result[RESULR_TWO]); 
+        float f2 = atof(result[RESULR_TWO]);
         float fdelta = f2 - faaa;
         LOG("LOGdisDataTest--faaa=  %f", faaa);
         LOG("LOGdisDataTest--f2 =  %f", f2);
@@ -336,7 +336,7 @@ int processGetData(char* putData)
       {
         LOG("LOGdisDataTest--math_score_double ");
         double daaa = TransferByteArrayToType<double>(valueRetInt.Data());
-        double d2 = atof(result[RESULR_TWO]); 
+        double d2 = atof(result[RESULR_TWO]);
         double delta = d2 - daaa;
         LOG("LOGdisDataTest--daaa=  %f", daaa);
         LOG("LOGdisDataTest--d2 =  %f", d2);
@@ -384,9 +384,9 @@ int processGetData(char* putData)
     }
     else  if(strcmp(result[1], "math_score_vector") == 0)
     { 
-       LOG("LOGdisDataTest--result[RESULR_TWO]=  %s", result[RESULR_TWO]);
-       LOG("LOGdisDataTest--ret.c_str() =  %s", ret.c_str());  
-        if(strcmp(result[RESULR_TWO], ret.c_str()) == 0)
+        LOG("LOGdisDataTest--result[RESULR_TWO]=  %s", result[RESULR_TWO]);
+        LOG("LOGdisDataTest--ret.c_str() =  %s", ret.c_str());  
+        if (strcmp(result[RESULR_TWO], ret.c_str()) == 0)
         {
             return RESULT_OK;
         }
diff --git a/distributeddatamgr/process_common/process_msg.h b/distributeddatamgr/process_common/process_msg.h
index 0751e2a..a274b52 100644
--- a/distributeddatamgr/process_common/process_msg.h
+++ b/distributeddatamgr/process_common/process_msg.h
@@ -16,20 +16,20 @@
 #ifndef TEST_PROCESS_MSG_H
 #define TEST_PROCESS_MSG_H
 
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #include <unistd.h>
-#include <stdint.h>
+#include <cstdint>
 #include <pthread.h>
-#include <stdarg.h>
+#include <cstdarg>
 #include "distributed_kv_data_manager.h"
 #include <sys/time.h>
 
-#define MAX_DATA_LENGTH 1024
-#define RESULT_OK  0
-#define RESULT_ERR 1
+const int MAX_DATA_LENGTH = 1024;
+const int RESULT_OK = 0;
+const int RESULT_ERR = 1;
 
 typedef enum{
     CTRL_CODE_SOFTBUS_TYPE = 1000,
@@ -78,5 +78,5 @@ int processCreateKv(char* putData);
 int processDeleteKv(char* putData);
 char* getRealData(char* str, char* delims);
 void getParam(char* str, char ret[] [MAX_DATA_LENGTH]);
-void initKvstoreId();
-#endif
+void initKvstoreId(void);
+#endif
\ No newline at end of file