diff --git a/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp b/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
index fc509ff744f1b62964f286a87b3a6dc922ff78ed..2399a18eff94ca990525dc2ace5a8be6adfc64b8 100644
--- a/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
+++ b/services/distributeddataservice/app/src/session_manager/route_head_handler_impl.cpp
@@ -156,6 +156,10 @@ DistributedDB::DBStatus RouteHeadHandlerImpl::GetHeadDataSize(uint32_t &headSize
 DistributedDB::DBStatus RouteHeadHandlerImpl::FillHeadData(uint8_t *data, uint32_t headSize, uint32_t totalLen)
 {
     ZLOGD("begin");
+    if (data == nullptr) {
+        ZLOGE("data is nullptr");
+        return DistributedDB::DB_ERROR;
+    }
     if (headSize != headSize_) {
         ZLOGI("size not match");
         return DistributedDB::DB_ERROR;
diff --git a/services/distributeddataservice/app/test/unittest/session_manager_test.cpp b/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
index d45a2819ba11837cd872375c638c6a635d041119..f08136914b96789695d27479c26ea2aa7b88a1fe 100644
--- a/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
+++ b/services/distributeddataservice/app/test/unittest/session_manager_test.cpp
@@ -17,10 +17,12 @@
 
 #include <cstdint>
 
+#include "access_check/app_access_check_config_manager.h"
 #include "accesstoken_kit.h"
 #include "account_delegate_mock.h"
 #include "auth_delegate_mock.h"
 #include "bootstrap.h"
+#include "db_store_mock.h"
 #include "device_manager_adapter.h"
 #include "device_manager_adapter_mock.h"
 #include "gtest/gtest.h"
@@ -45,7 +47,9 @@ using namespace OHOS;
 using namespace OHOS::Security::AccessToken;
 using DeviceInfo = OHOS::AppDistributedKv::DeviceInfo;
 using UserInfo = DistributedDB::UserInfo;
+using AppMappingInfo = OHOS::DistributedData::AppAccessCheckConfigManager::AppMappingInfo;
 constexpr const char *PEER_DEVICE_ID = "PEER_DEVICE_ID";
+constexpr const char *DEFAULT_USERID = "0";
 constexpr int PEER_USER_ID1 = 101;
 constexpr int PEER_USER_ID2 = 100;
 constexpr int32_t USER_MAXID = 4;
@@ -83,7 +87,8 @@ public:
             users.push_back(stat);
         }
     }
-    void CreateStoreMetaData(std::vector<StoreMetaData> &datas, SessionPoint local)
+
+    static void CreateStoreMetaData(std::vector<StoreMetaData> &datas, SessionPoint local)
     {
         StoreMetaData data;
         data.appId = local.appId;
@@ -106,17 +111,10 @@ public:
         datas.push_back(data2);
         datas.push_back(data3);
     }
+
     static void SetUpTestCase()
     {
-        deviceManagerAdapterMock = std::make_shared<DeviceManagerAdapterMock>();
-        BDeviceManagerAdapter::deviceManagerAdapter = deviceManagerAdapterMock;
-        metaDataManagerMock = std::make_shared<MetaDataManagerMock>();
-        BMetaDataManager::metaDataManager = metaDataManagerMock;
-        metaDataMock = std::make_shared<MetaDataMock<StoreMetaData>>();
-        BMetaData<StoreMetaData>::metaDataManager = metaDataMock;
-        userDelegateMock = std::make_shared<UserDelegateMock>();
-        BUserDelegate::userDelegate = userDelegateMock;
-
+        MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, "");
         auto executors = std::make_shared<ExecutorPool>(12, 5);
         Bootstrap::GetInstance().LoadComponents();
         Bootstrap::GetInstance().LoadDirectory();
@@ -142,51 +140,42 @@ public:
 
         auto peerCapMetaKey = CapMetaRow::GetKeyFor(userMetaData.deviceId);
         MetaDataManager::GetInstance().SaveMeta({ peerCapMetaKey.begin(), peerCapMetaKey.end() }, capMetaData);
-
-        StoreMetaData metaData;
-        metaData.bundleName = "ohos.test.demo";
-        metaData.appId = "ohos.test.demo";
-        metaData.storeId = "test_store";
-        metaData.user = "100";
-        metaData.deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
-        metaData.tokenId = AccessTokenKit::GetHapTokenID(PEER_USER_ID2, "ohos.test.demo", 0);
-        metaData.uid = METADATA_UID;
-        metaData.storeType = 1;
-        MetaDataManager::GetInstance().SaveMeta(metaData.GetKeyWithoutPath(), metaData);
+        InitSystemMetaData();
+        InitNormalMetaData();
         GrantPermissionNative();
     }
+
     static void TearDownTestCase()
     {
         auto peerUserMetaKey = UserMetaRow::GetKeyFor(PEER_DEVICE_ID);
         MetaDataManager::GetInstance().DelMeta(std::string(peerUserMetaKey.begin(), peerUserMetaKey.end()));
         auto peerCapMetaKey = CapMetaRow::GetKeyFor(PEER_DEVICE_ID);
         MetaDataManager::GetInstance().DelMeta(std::string(peerCapMetaKey.begin(), peerCapMetaKey.end()));
-        StoreMetaData metaData;
-        metaData.bundleName = "ohos.test.demo";
-        metaData.appId = "ohos.test.demo";
-        metaData.storeId = "test_store";
-        metaData.user = "100";
-        metaData.deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
-        metaData.tokenId = AccessTokenKit::GetHapTokenID(PEER_USER_ID2, "ohos.test.demo", 0);
-        metaData.uid = METADATA_UID;
-        metaData.storeType = 1;
-        MetaDataManager::GetInstance().DelMeta(metaData.GetKeyWithoutPath());
-        deviceManagerAdapterMock = nullptr;
-        BDeviceManagerAdapter::deviceManagerAdapter = nullptr;
-        metaDataManagerMock = nullptr;
-        BMetaDataManager::metaDataManager = nullptr;
-        metaDataMock = nullptr;
-        BMetaData<StoreMetaData>::metaDataManager = nullptr;
-        userDelegateMock = nullptr;
-        BUserDelegate::userDelegate = nullptr;
     }
+
     void SetUp()
     {
+        deviceManagerAdapterMock = std::make_shared<DeviceManagerAdapterMock>();
+        BDeviceManagerAdapter::deviceManagerAdapter = deviceManagerAdapterMock;
+        userDelegateMock = std::make_shared<UserDelegateMock>();
+        BUserDelegate::userDelegate = userDelegateMock;
         ConstructValidData();
+        auto res = MetaDataManager::GetInstance().SaveMeta(systemMetaData_.GetKey(), systemMetaData_);
+        EXPECT_EQ(res, true);
+        res = MetaDataManager::GetInstance().SaveMeta(normalMetaData_.GetKey(), normalMetaData_);
+        EXPECT_EQ(res, true);
     }
+
     void TearDown()
     {
+        deviceManagerAdapterMock = nullptr;
+        BDeviceManagerAdapter::deviceManagerAdapter = nullptr;
+        userDelegateMock = nullptr;
+        BUserDelegate::userDelegate = nullptr;
+        MetaDataManager::GetInstance().DelMeta(systemMetaData_.GetKey());
+        MetaDataManager::GetInstance().DelMeta(normalMetaData_.GetKey());
     }
+
     void ConstructValidData()
     {
         const std::string storeId = "test_store";
@@ -203,9 +192,13 @@ public:
         validTotalLen = validlLen;
     }
 
+    static void InitSystemMetaData();
+    static void InitNormalMetaData();
+    static std::shared_ptr<DBStoreMock> dbStoreMock_;
+    static StoreMetaData systemMetaData_;
+    static StoreMetaData normalMetaData_;
+
     static inline std::shared_ptr<DeviceManagerAdapterMock> deviceManagerAdapterMock = nullptr;
-    static inline std::shared_ptr<MetaDataManagerMock> metaDataManagerMock = nullptr;
-    static inline std::shared_ptr<MetaDataMock<StoreMetaData>> metaDataMock = nullptr;
     static inline std::shared_ptr<UserDelegateMock> userDelegateMock = nullptr;
 
 private:
@@ -233,7 +226,7 @@ private:
 
     void ConstructSessionDevicePair()
     {
-        SessionDevicePair devPair{};
+        SessionDevicePair devPair{ .sourceId = "PEER_DEVICE_ID", .targetId = "PEER_DEVICE_ID" };
         constexpr size_t DEV_ID_SIZE = sizeof(devPair.sourceId);
 
         errno_t err = memset_s(devPair.sourceId, DEV_ID_SIZE, 'A', DEV_ID_SIZE - 1);
@@ -284,6 +277,7 @@ private:
         ptr += APP_STR_LEN;
         remaining -= APP_STR_LEN;
     }
+
     void ConstructSessionStoreId(const std::string &storeId)
     {
         SessionStoreId storeIdHeader{};
@@ -299,6 +293,7 @@ private:
         ptr += storeId.size();
         remaining -= storeId.size();
     }
+
     size_t validTotalLen;
     uint8_t dataBuffer[1024];
     static constexpr size_t APP_STR_LEN = 4;
@@ -307,6 +302,34 @@ private:
     static constexpr size_t BUFFER_SIZE = sizeof(dataBuffer);
 };
 
+std::shared_ptr<DBStoreMock> SessionManagerTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
+StoreMetaData SessionManagerTest::systemMetaData_;
+StoreMetaData SessionManagerTest::normalMetaData_;
+
+void SessionManagerTest::InitNormalMetaData()
+{
+    normalMetaData_.bundleName = "ohos.test.demo";
+    normalMetaData_.appId = "ohos.test.demo";
+    normalMetaData_.storeId = "test_store";
+    normalMetaData_.user = "100";
+    normalMetaData_.deviceId = "local_device";
+    normalMetaData_.tokenId = AccessTokenKit::GetHapTokenID(PEER_USER_ID2, "ohos.test.demo", 0);
+    normalMetaData_.uid = METADATA_UID;
+    normalMetaData_.storeType = 1;
+}
+
+void SessionManagerTest::InitSystemMetaData()
+{
+    systemMetaData_.bundleName = "ohos.test.demo";
+    systemMetaData_.appId = "ohos.test.demo";
+    systemMetaData_.storeId = "test_store";
+    systemMetaData_.user = DEFAULT_USERID;
+    systemMetaData_.deviceId = "local_device";
+    systemMetaData_.tokenId = AccessTokenKit::GetHapTokenID(PEER_USER_ID2, "ohos.test.demo", 0);
+    systemMetaData_.uid = METADATA_UID;
+    systemMetaData_.storeType = 1;
+}
+
 /**
   * @tc.name: PackAndUnPack01
   * @tc.desc: test get db dir
@@ -337,6 +360,7 @@ HWTEST_F(SessionManagerTest, PackAndUnPack01, TestSize.Level2)
     recvHandler->ParseHeadDataUser(data.get(), routeHeadSize, "", users);
     ASSERT_EQ(users.size(), 0);
 }
+
 /**
   * @tc.name: GetHeadDataSize_Test1
   * @tc.desc: test appId equal processLabel.
@@ -349,11 +373,11 @@ HWTEST_F(SessionManagerTest, GetHeadDataSize_Test1, TestSize.Level1)
     RouteHeadHandlerImpl routeHeadHandlerImpl(info);
     uint32_t headSize = 0;
     routeHeadHandlerImpl.appId_ = Bootstrap::GetInstance().GetProcessLabel();
-    routeHeadHandlerImpl.storeId_ = Bootstrap::GetInstance().GetMetaDBName();
     auto status = routeHeadHandlerImpl.GetHeadDataSize(headSize);
     EXPECT_EQ(status, DistributedDB::OK);
     EXPECT_EQ(headSize, 0);
 }
+
 /**
   * @tc.name: GetHeadDataSize_Test2
   * @tc.desc: test appId not equal processLabel.
@@ -370,6 +394,7 @@ HWTEST_F(SessionManagerTest, GetHeadDataSize_Test2, TestSize.Level1)
     EXPECT_EQ(status, DistributedDB::DB_ERROR);
     EXPECT_EQ(headSize, 0);
 }
+
 /**
   * @tc.name: GetHeadDataSize_Test3
   * @tc.desc: test devInfo.osType equal OH_OS_TYPE, appId not equal processLabel.
@@ -389,6 +414,7 @@ HWTEST_F(SessionManagerTest, GetHeadDataSize_Test3, TestSize.Level1)
     EXPECT_EQ(status, DistributedDB::DB_ERROR);
     EXPECT_EQ(headSize, 0);
 }
+
 /**
   * @tc.name: GetHeadDataSize_Test4
   * @tc.desc: test GetHeadDataSize
@@ -403,15 +429,14 @@ HWTEST_F(SessionManagerTest, GetHeadDataSize_Test4, TestSize.Level1)
     EXPECT_CALL(*deviceManagerAdapterMock, GetDeviceInfo(_)).WillRepeatedly(Return(deviceInfo));
 
     const DistributedDB::ExtendInfo info = {
-        .appId = "otherAppId", .storeId = "test_store", .userId = "100", .dstTarget = PEER_DEVICE_ID
+        .appId = "otherAppId", .storeId = "test_store", .userId = DEFAULT_USERID, .dstTarget = PEER_DEVICE_ID
     };
     auto sendHandler = RouteHeadHandlerImpl::Create(info);
     ASSERT_NE(sendHandler, nullptr);
 
-    CapMetaData capMetaData;
-    capMetaData.version = CapMetaData::CURRENT_VERSION;
-    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _))
-        .WillRepeatedly(DoAll(SetArgReferee<1>(capMetaData), Return(true)));
+    auto userId = sendHandler->GetTargetUserId();
+    EXPECT_EQ(userId, "0");
+
     std::vector<UserStatus> userStatus;
     UserStatus userStat1;
     UserStatus userStat2;
@@ -427,13 +452,208 @@ HWTEST_F(SessionManagerTest, GetHeadDataSize_Test4, TestSize.Level1)
     uint32_t headSize = 0;
     auto status = sendHandler->GetHeadDataSize(headSize);
     EXPECT_EQ(status, DistributedDB::OK);
-    EXPECT_EQ(headSize, 0);
+    EXPECT_EQ(headSize, 208);
 
     uint32_t routeHeadSize = 10;
     std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(routeHeadSize);
     status = sendHandler->FillHeadData(data.get(), routeHeadSize, routeHeadSize);
     EXPECT_EQ(status, DistributedDB::DB_ERROR);
 }
+
+/**
+  * @tc.name: GetHeadDataSize_Test5
+  * @tc.desc: test device is not OH_OS_TYPE and appId is empty.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, GetHeadDataSize_Test5, TestSize.Level1)
+{
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillOnce(Return(true)).WillOnce(Return(false));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "", .storeId = "test_store", .userId = "100", .dstTarget = PEER_DEVICE_ID
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+    uint32_t headSize;
+    auto status = sendHandler->GetHeadDataSize(headSize);
+    EXPECT_EQ(status, DistributedDB::DB_ERROR);
+    EXPECT_EQ(headSize, 0);
+}
+
+/**
+  * @tc.name: GetHeadDataSize_Test6
+  * @tc.desc: test device != OH_OS_TYPE && appId.isNotEmpty && appId.isTrusted.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, GetHeadDataSize_Test6, TestSize.Level1)
+{
+    const DistributedDB::ExtendInfo info = {
+        .appId = "com.test.demo", .storeId = "test", .userId = "100", .dstTarget = PEER_DEVICE_ID
+    };
+    std::vector<AppMappingInfo> mapper = { { .appId = info.appId, .bundleName = info.appId } };
+    AppAccessCheckConfigManager::GetInstance().Initialize(mapper);
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+    uint32_t headSize;
+    auto status = sendHandler->GetHeadDataSize(headSize);
+    EXPECT_EQ(status, DistributedDB::OK);
+    EXPECT_EQ(headSize, 0);
+}
+
+/**
+  * @tc.name: GetHeadDataSize_Test7
+  * @tc.desc: test GetCapability is failed.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, GetHeadDataSize_Test7, TestSize.Level1)
+{
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillRepeatedly(Return(true));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "otherAppId", .storeId = "test", .userId = "100", .dstTarget = "10"
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+    uint32_t headSize;
+    auto status = sendHandler->GetHeadDataSize(headSize);
+    EXPECT_EQ(status, DistributedDB::DB_ERROR);
+    EXPECT_EQ(headSize, 0);
+}
+
+/**
+  * @tc.name: GetHeadDataSize_Test8
+  * @tc.desc: test peerCap.version != INALID_VERSION && session is invalid.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, GetHeadDataSize_Test8, TestSize.Level1)
+{
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillRepeatedly(Return(true));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "otherAppId", .storeId = "test", .userId = "100", .dstTarget = PEER_DEVICE_ID
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+    uint32_t headSize;
+    auto status = sendHandler->GetHeadDataSize(headSize);
+    EXPECT_EQ(status, DistributedDB::DB_ERROR);
+    EXPECT_EQ(headSize, 0);
+}
+
+/**
+  * @tc.name: GetHeadDataSize_Test9
+  * @tc.desc: test peerCap.version != INALID_VERSION && session is valid.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, GetHeadDataSize_Test9, TestSize.Level1)
+{
+    DeviceInfo deviceInfo;
+    deviceInfo.uuid = PEER_DEVICE_ID;
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillRepeatedly(Return(true));
+    EXPECT_CALL(*deviceManagerAdapterMock, GetLocalDevice()).WillRepeatedly(Return(deviceInfo));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "test", .storeId = "test_store", .userId = DEFAULT_USERID, .dstTarget = PEER_DEVICE_ID
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+    uint32_t headSize;
+    auto status = sendHandler->GetHeadDataSize(headSize);
+    EXPECT_EQ(status, DistributedDB::OK);
+    EXPECT_EQ(headSize, 200);
+
+    uint32_t totalLen = 300;
+    std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(totalLen);
+    status = sendHandler->FillHeadData(data.get(), headSize, totalLen);
+    EXPECT_EQ(status, DistributedDB::OK);
+    uint32_t parseHeadSize;
+    auto res = sendHandler->ParseHeadDataLen(data.get(), totalLen, parseHeadSize, info.storeId);
+    EXPECT_EQ(res, true);
+    EXPECT_EQ(parseHeadSize, 200);
+
+    std::vector<UserInfo> userInfos;
+    std::string label;
+    res = sendHandler->ParseHeadDataUser(data.get(), totalLen, label, userInfos);
+    EXPECT_EQ(res, true);
+    EXPECT_EQ(label, "");
+    EXPECT_EQ(userInfos.size(), 1);
+}
+
+/**
+  * @tc.name: ParseHeadDataLenTest001
+  * @tc.desc: test ParseHeadDataLen data is nullptr.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, ParseHeadDataLenTest001, TestSize.Level1)
+{
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillRepeatedly(Return(true));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "otherAppId", .storeId = "test_store", .userId = "100", .dstTarget = PEER_DEVICE_ID
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+
+    uint32_t totalLen = 10;
+    uint32_t headSize;
+    std::string device = "device";
+
+    bool result = sendHandler->ParseHeadDataLen(nullptr, totalLen, headSize, device);
+    EXPECT_EQ(result, false);
+
+    auto status = sendHandler->FillHeadData(nullptr, headSize, headSize);
+    EXPECT_EQ(status, DistributedDB::DB_ERROR);
+}
+
+/**
+  * @tc.name: ParseHeadDataLenTest002
+  * @tc.desc: test ParseHeadDataLen totalLen < sizeof(RouteHead).
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, ParseHeadDataLenTest002, TestSize.Level1)
+{
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillRepeatedly(Return(true));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "otherAppId", .storeId = "test_store", .userId = "100", .dstTarget = PEER_DEVICE_ID
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+
+    uint32_t totalLen = 10;
+    uint32_t headSize;
+    std::string device = "device";
+
+    bool result = sendHandler->ParseHeadDataLen(dataBuffer, totalLen, headSize, device);
+    EXPECT_EQ(result, false);
+    EXPECT_EQ(headSize, 0);
+}
+
+/**
+  * @tc.name: ParseHeadDataLenTest003
+  * @tc.desc: test ParseHeadDataLen totalLen - sizeof(RouteHead) < routeHead.dataLen.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, ParseHeadDataLenTest003, TestSize.Level1)
+{
+    EXPECT_CALL(*deviceManagerAdapterMock, IsOHOSType(_)).WillRepeatedly(Return(true));
+    const DistributedDB::ExtendInfo info = {
+        .appId = "otherAppId", .storeId = "test_store", .userId = "100", .dstTarget = PEER_DEVICE_ID
+    };
+    auto sendHandler = RouteHeadHandlerImpl::Create(info);
+    ASSERT_NE(sendHandler, nullptr);
+
+    uint32_t totalLen = 20;
+    uint32_t headSize;
+    std::string device = "device";
+
+    bool result = sendHandler->ParseHeadDataLen(dataBuffer, totalLen, headSize, device);
+    EXPECT_EQ(result, false);
+    EXPECT_EQ(headSize, 0);
+}
+
 /**
   * @tc.name: ParseHeadDataUserTest001
   * @tc.desc: test parse null data.
@@ -449,6 +669,8 @@ HWTEST_F(SessionManagerTest, ParseHeadDataUserTest001, TestSize.Level1)
     auto sendHandler = RouteHeadHandlerImpl::Create(info);
     ASSERT_NE(sendHandler, nullptr);
 
+    auto userId = sendHandler->GetTargetUserId();
+    EXPECT_EQ(userId, "");
     uint32_t totalLen = 10;
     std::string label = "testLabel";
     std::vector<UserInfo> userInfos;
@@ -458,6 +680,7 @@ HWTEST_F(SessionManagerTest, ParseHeadDataUserTest001, TestSize.Level1)
     EXPECT_FALSE(result);
     EXPECT_EQ(userInfos.size(), 0);
 }
+
 /**
   * @tc.name: ParseHeadDataUserTest002
   * @tc.desc: test totalLen < sizeof(RouteHead).
@@ -512,6 +735,36 @@ HWTEST_F(SessionManagerTest, ParseHeadDataUserTest003, TestSize.Level1)
     EXPECT_EQ(userInfos.size(), 0);
 }
 
+/**
+  * @tc.name: PackDataTest1
+  * @tc.desc: test headSize_ > totalLen.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, PackDataTest1, TestSize.Level1)
+{
+    ExtendInfo info;
+    RouteHeadHandlerImpl routeHeadHandlerImpl(info);
+    routeHeadHandlerImpl.headSize_ = 1;
+    uint32_t totalLen = 0;
+    EXPECT_EQ(routeHeadHandlerImpl.PackData(dataBuffer, totalLen), false);
+}
+
+/**
+  * @tc.name: PackDataTest2
+  * @tc.desc: test headSize_ < sizeof(RouteHead).
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, PackDataTest2, TestSize.Level1)
+{
+    ExtendInfo info;
+    RouteHeadHandlerImpl routeHeadHandlerImpl(info);
+    routeHeadHandlerImpl.headSize_ = 10;
+    uint32_t totalLen = 11;
+    EXPECT_EQ(routeHeadHandlerImpl.PackData(dataBuffer, totalLen), false);
+}
+
 /**
   * @tc.name: UnPackData_InvalidMagic
   * @tc.desc: test invalid magic.
@@ -545,18 +798,63 @@ HWTEST_F(SessionManagerTest, UnPackData_VersionMismatch, TestSize.Level1)
 }
 
 /**
-  * @tc.name: UnPackData_ValidData
-  * @tc.desc: test valid data.
+  * @tc.name: UnPackDataBody01
+  * @tc.desc: test leftSize < sizeof(SessionDevicePair).
   * @tc.type: FUNC
   * @tc.author: guochao
   */
-HWTEST_F(SessionManagerTest, UnPackData_ValidData, TestSize.Level1)
+HWTEST_F(SessionManagerTest, UnPackDataBody01, TestSize.Level1)
 {
     ExtendInfo info;
     RouteHeadHandlerImpl routeHeadHandlerImpl(info);
-    uint32_t unpackedSize;
-    EXPECT_TRUE(routeHeadHandlerImpl.UnPackData(dataBuffer, validTotalLen, unpackedSize));
-    EXPECT_EQ(unpackedSize, validTotalLen);
+    uint32_t totalLen = 100;
+    auto res = routeHeadHandlerImpl.UnPackDataBody(dataBuffer, totalLen);
+    EXPECT_EQ(res, false);
+}
+
+/**
+  * @tc.name: UnPackDataBody02
+  * @tc.desc: test leftSize < sizeof(SessionUserPair).
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, UnPackDataBody02, TestSize.Level1)
+{
+    ExtendInfo info;
+    RouteHeadHandlerImpl routeHeadHandlerImpl(info);
+    uint32_t totalLen = 133;
+    auto res = routeHeadHandlerImpl.UnPackDataBody(dataBuffer, totalLen);
+    EXPECT_EQ(res, false);
+}
+
+/**
+  * @tc.name: UnPackDataBody03
+  * @tc.desc: test leftSize < userPairSize.
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, UnPackDataBody03, TestSize.Level1)
+{
+    ExtendInfo info;
+    RouteHeadHandlerImpl routeHeadHandlerImpl(info);
+    uint32_t totalLen = 136;
+    auto res = routeHeadHandlerImpl.UnPackDataBody(dataBuffer, totalLen);
+    EXPECT_EQ(res, false);
+}
+
+/**
+  * @tc.name: UnPackDataBody05
+  * @tc.desc: test leftSize < sizeof(SessionAppId).
+  * @tc.type: FUNC
+  * @tc.author: guochao
+  */
+HWTEST_F(SessionManagerTest, UnPackDataBody05, TestSize.Level1)
+{
+    ExtendInfo info;
+    RouteHeadHandlerImpl routeHeadHandlerImpl(info);
+    uint32_t totalLen = 400;
+    auto res = routeHeadHandlerImpl.UnPackDataBody(dataBuffer, totalLen);
+    EXPECT_EQ(res, false);
 }
 
 /**
@@ -569,7 +867,7 @@ HWTEST_F(SessionManagerTest, ShouldAddSystemUserWhenLocalUserIdIsSystem, TestSiz
 {
     SessionPoint local;
     local.userId = UserDelegate::SYSTEM_USER;
-    local.appId = "test_app";
+    local.appId = "ohos.test.demo";
     local.deviceId = "local_device";
     local.storeId = "test_store";
 
@@ -581,11 +879,7 @@ HWTEST_F(SessionManagerTest, ShouldAddSystemUserWhenLocalUserIdIsSystem, TestSiz
         .WillOnce(Return(std::pair(true, false)))
         .WillOnce(Return(std::pair(false, true)))
         .WillOnce(Return(std::pair(false, false)));
-    std::vector<StoreMetaData> datas;
-    CreateStoreMetaData(datas, local);
-    EXPECT_CALL(*metaDataMock, LoadMeta(_, _, _)).WillRepeatedly(DoAll(SetArgReferee<1>(datas), Return(true)));
-
-    Session session = SessionManager::GetInstance().GetSession(local, "target_device");
+    Session session = SessionManager::GetInstance().GetSession(local, local.deviceId);
     ASSERT_EQ(2, session.targetUserIds.size());
     EXPECT_EQ(UserDelegate::SYSTEM_USER, session.targetUserIds[0]);
 }
@@ -603,8 +897,6 @@ HWTEST_F(SessionManagerTest, ShouldReturnEarlyWhenGetSendAuthParamsFails, TestSi
     local.appId = "test_app";
     local.deviceId = "local_device";
     EXPECT_CALL(*userDelegateMock, GetRemoteUserStatus(_)).WillOnce(Return(std::vector<UserStatus>{}));
-    std::vector<StoreMetaData> datas;
-    EXPECT_CALL(*metaDataMock, LoadMeta(_, _, _)).WillRepeatedly(Return(false));
 
     Session session = SessionManager::GetInstance().GetSession(local, "target_device");
 
@@ -621,24 +913,20 @@ HWTEST_F(SessionManagerTest, CheckSession, TestSize.Level1)
 {
     SessionPoint localSys;
     localSys.userId = UserDelegate::SYSTEM_USER;
-    localSys.appId = "test_app";
+    localSys.appId = "ohos.test.demo";
     localSys.deviceId = "local_device";
     localSys.storeId = "test_store";
     SessionPoint localNormal;
     localNormal.userId = 100;
-    localNormal.appId = "test_app";
+    localNormal.appId = "ohos.test.demo";
     localNormal.deviceId = "local_device";
     localNormal.storeId = "test_store";
     localNormal.accountId = "test_account";
-    std::vector<StoreMetaData> datas;
-    CreateStoreMetaData(datas, localSys);
-    EXPECT_CALL(*metaDataMock, LoadMeta(_, _, _))
-        .WillOnce(DoAll(SetArgReferee<1>(datas), Return(false)))
-        .WillRepeatedly(DoAll(SetArgReferee<1>(datas), Return(true)));
+    SessionPoint invalidPoint;
     EXPECT_CALL(AuthHandlerMock::GetInstance(), CheckAccess(_, _, _, _))
         .WillOnce(Return(std::pair(false, true)))
         .WillOnce(Return(std::pair(true, false)));
-    bool result = SessionManager::GetInstance().CheckSession(localSys, localNormal, true);
+    bool result = SessionManager::GetInstance().CheckSession(invalidPoint, invalidPoint, true);
     EXPECT_FALSE(result);
     result = SessionManager::GetInstance().CheckSession(localSys, localNormal, true);
     EXPECT_FALSE(result);
diff --git a/services/distributeddataservice/service/test/mock/BUILD.gn b/services/distributeddataservice/service/test/mock/BUILD.gn
index f16449ab33a2c8d80462e101360ff13ecd0fe03b..10ea0e49325847be0bbc7feaa0e898980fa878cd 100644
--- a/services/distributeddataservice/service/test/mock/BUILD.gn
+++ b/services/distributeddataservice/service/test/mock/BUILD.gn
@@ -45,7 +45,6 @@ ohos_static_library("distributeddata_mock_static") {
     "device_manager_adapter_mock.cpp",
     "general_store_mock.cpp",
     "kv_store_nb_delegate_mock.cpp",
-    "meta_data_manager_mock.cpp",
     "network_delegate_mock.cpp",
     "screen_lock_mock.cpp",
     "user_delegate_mock.cpp",