diff --git a/services/security_component_service/sa/test/mock/src/sec_comp_enhance_adapter.cpp b/services/security_component_service/sa/test/mock/src/sec_comp_enhance_adapter.cpp
index e0756ccb7a0587aba4365614e0e48c71bf62e17b..268fadb122c4ed8187d2e11440983cd2bb2963a1 100644
--- a/services/security_component_service/sa/test/mock/src/sec_comp_enhance_adapter.cpp
+++ b/services/security_component_service/sa/test/mock/src/sec_comp_enhance_adapter.cpp
@@ -69,33 +69,46 @@ bool SecCompEnhanceAdapter::EnhanceDataPreprocess(int32_t scId, std::string& com
 }
 
 #ifndef FUZZ_ENABLE
-static bool MessageParcelToRawdata(MessageParcel& input, SecCompRawdata& output)
+bool WriteMessageParcel(MessageParcel& tmpData, SecCompRawdata& data)
 {
-    if (!input.ReadUint32(output.size)) {
-        SC_LOG_ERROR(LABEL, "Read size failed.");
-        return false;
+    size_t bufferLength = tmpData.GetDataSize();
+    if (bufferLength == 0) {
+        SC_LOG_INFO(LABEL, "TmpData is empty.");
+        return true;
     }
-    auto readrawReply = input.ReadRawData(output.size);
-    if (readrawReply == nullptr) {
-        SC_LOG_ERROR(LABEL, "Read data failed.");
+
+    char* buffer = reinterpret_cast<char *>(tmpData.GetData());
+    if (buffer == nullptr) {
+        SC_LOG_ERROR(LABEL, "Get tmpData data failed.");
         return false;
     }
-    int32_t res = output.RawDataCpy(readrawReply);
-    if (res != SC_OK) {
-        SC_LOG_ERROR(LABEL, "Copy memory to output failed.");
+
+    data.size = bufferLength;
+    int32_t ret = data.RawDataCpy(reinterpret_cast<void *>(buffer));
+    if (ret != SC_OK) {
+        SC_LOG_ERROR(LABEL, "Copy tmpData to rawdata failed.");
         return false;
     }
     return true;
 }
 
-static bool RawdataToMessageParcel(const SecCompRawdata& input, MessageParcel& output)
+bool ReadMessageParcel(SecCompRawdata& tmpData, MessageParcel& data)
 {
-    if (!output.WriteUint32(input.size)) {
-        SC_LOG_ERROR(LABEL, "Write size failed.");
+    int32_t size = tmpData.size;
+    if (size == 0) {
+        SC_LOG_INFO(LABEL, "Read tmpData length empty.");
+        return true;
+    }
+    
+    const void *iter = tmpData.data;
+    if (iter == nullptr) {
+        SC_LOG_ERROR(LABEL, "Read const void failed.");
         return false;
     }
-    if (!output.WriteRawData(input.data, input.size)) {
-        SC_LOG_ERROR(LABEL, "Write data failed.");
+    char* ptr = reinterpret_cast<char *>(const_cast<void *>(iter));
+
+    if (!data.WriteBuffer(reinterpret_cast<void *>(ptr), size)) {
+        SC_LOG_ERROR(LABEL, "Write buffer failed.");
         return false;
     }
     return true;
@@ -104,25 +117,25 @@ static bool RawdataToMessageParcel(const SecCompRawdata& input, MessageParcel& o
 bool SecCompEnhanceAdapter::EnhanceClientSerialize(MessageParcel& input, SecCompRawdata& output)
 {
     SC_LOG_DEBUG(LABEL, "EnhanceClientSerialize successful.");
-    return MessageParcelToRawdata(input, output);
+    return WriteMessageParcel(input, output);
 }
 
 bool SecCompEnhanceAdapter::EnhanceClientDeserialize(SecCompRawdata& input, MessageParcel& output)
 {
     SC_LOG_DEBUG(LABEL, "EnhanceClientDeserialize successful.");
-    return RawdataToMessageParcel(input, output);
+    return ReadMessageParcel(input, output);
 }
 
 bool SecCompEnhanceAdapter::EnhanceSrvSerialize(MessageParcel& input, SecCompRawdata& output)
 {
     SC_LOG_DEBUG(LABEL, "EnhanceSrvSerialize successful.");
-    return MessageParcelToRawdata(input, output);
+    return WriteMessageParcel(input, output);
 }
 
 bool SecCompEnhanceAdapter::EnhanceSrvDeserialize(SecCompRawdata& input, MessageParcel& output)
 {
     SC_LOG_DEBUG(LABEL, "EnhanceSrvDeserialize successful.");
-    return RawdataToMessageParcel(input, output);
+    return ReadMessageParcel(input, output);
 }
 #else
 bool WriteMessageParcel(MessageParcel& tmpData, SecCompRawdata& data)
diff --git a/services/security_component_service/sa/test/unittest/src/sec_comp_service_mock_test.cpp b/services/security_component_service/sa/test/unittest/src/sec_comp_service_mock_test.cpp
index 12bf961b32061c07d159196b16619529603f2bf6..14ad3db5e078ad076896800f7fb16d65124ba8a6 100644
--- a/services/security_component_service/sa/test/unittest/src/sec_comp_service_mock_test.cpp
+++ b/services/security_component_service/sa/test/unittest/src/sec_comp_service_mock_test.cpp
@@ -22,6 +22,7 @@
 #include "save_button.h"
 #include "sec_comp_client.h"
 #include "sec_comp_err.h"
+#include "sec_comp_info.h"
 #include "sec_comp_log.h"
 #include "sec_comp_tool.h"
 #include "sec_comp_enhance_adapter.h"
@@ -73,12 +74,78 @@ void SecCompServiceMockTest::TearDown()
 }
 
 /**
- * @tc.name: RegisterSecurityComponent001
+ * @tc.name: WriteError001
+ * @tc.desc: Test WriteError
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, WriteError001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    SecCompRawdata rawReply;
+    EXPECT_EQ(SC_OK, secCompService_->WriteError(SC_SERVICE_ERROR_VALUE_INVALID, rawReply));
+}
+
+/**
+ * @tc.name: RegisterReadFromRawdata001
+ * @tc.desc: Test register read from rawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, RegisterReadFromRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+    SecCompType type;
+    std::string outComponentInfo;
+    uint32_t uintType;
+    std::string componentInfo;
+
+    // rawdata.data is nullptr
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
+        secCompService_->RegisterReadFromRawdata(rawdataVoid, type, outComponentInfo));
+
+    // Type is UNKONWN_SC_TYPE
+    uintType = 0;
+    data.WriteUint32(uintType);
+    data.WriteString(componentInfo);
+    SecCompRawdata rawdataSmallType;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataSmallType));
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
+        secCompService_->RegisterReadFromRawdata(rawdataSmallType, type, outComponentInfo));
+    data.FlushBuffer();
+
+    // Type is bigger than MAX_SC_TYPE
+    uintType = 100;
+    data.WriteUint32(uintType);
+    data.WriteString(componentInfo);
+    SecCompRawdata rawdataBigType;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBigType));
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
+        secCompService_->RegisterReadFromRawdata(rawdataBigType, type, outComponentInfo));
+    data.FlushBuffer();
+
+    // register read from rawdata OK
+    uintType = SAVE_COMPONENT;
+    data.WriteUint32(uintType);
+    data.WriteString(componentInfo);
+    SecCompRawdata rawdataValidType;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataValidType));
+    EXPECT_EQ(SC_OK, secCompService_->RegisterReadFromRawdata(rawdataValidType, type, outComponentInfo));
+    EXPECT_EQ(SAVE_COMPONENT, type);
+}
+
+/**
+ * @tc.name: RegisterSecurityComponentBody001
  * @tc.desc: Test register security component
  * @tc.type: FUNC
  * @tc.require:
  */
-HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent001, TestSize.Level1)
+HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponentBody001, TestSize.Level1)
 {
     // get caller fail
     int32_t scId;
@@ -123,12 +190,12 @@ HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent001, TestSize.Level1)
 }
 
 /**
- * @tc.name: RegisterSecurityComponent002
+ * @tc.name: RegisterSecurityComponentBody002
  * @tc.desc: Test register security component check touch info failed
  * @tc.type: FUNC
  * @tc.require:
  */
-HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent002, TestSize.Level1)
+HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponentBody002, TestSize.Level1)
 {
     int32_t scId;
     secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
@@ -160,12 +227,12 @@ HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent002, TestSize.Level1)
 }
 
 /**
- * @tc.name: RegisterSecurityComponent003
+ * @tc.name: RegisterSecurityComponentBody003
  * @tc.desc: Test register security component permission grant failed
  * @tc.type: FUNC
  * @tc.require:
  */
-HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent003, TestSize.Level1)
+HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponentBody003, TestSize.Level1)
 {
     int32_t scId;
     secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
@@ -203,12 +270,390 @@ HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent003, TestSize.Level1)
 }
 
 /**
- * @tc.name: ReportSecurityComponentClickEvent001
+ * @tc.name: RegisterWriteToRawdata001
+ * @tc.desc: Test register write to rawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, RegisterWriteToRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    int32_t scId = 1;
+    int32_t res = SC_OK;
+    SecCompRawdata rawReply;
+    EXPECT_EQ(SC_OK, secCompService_->RegisterWriteToRawdata(res, scId, rawReply));
+}
+
+/**
+ * @tc.name: RegisterSecurityComponent001
  * @tc.desc: Test register security component
  * @tc.type: FUNC
  * @tc.require:
  */
-HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEvent001, TestSize.Level1)
+HWTEST_F(SecCompServiceMockTest, RegisterSecurityComponent001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+    uint32_t uintType;
+
+    // RegisterReadFromRawdata fail
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    SecCompRawdata rawReplyReadFail;
+    MessageParcel replyReadFail;
+    EXPECT_EQ(SC_OK,
+        secCompService_->RegisterSecurityComponent(rawdataVoid, rawReplyReadFail));
+    SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyReadFail, replyReadFail);
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyReadFail.ReadInt32());
+
+    // RegisterSecurityComponentBody fail
+    uintType = SAVE_COMPONENT;
+    data.WriteUint32(uintType);
+    data.WriteString("");
+    SecCompRawdata rawdataBodyFail;
+    SecCompRawdata rawReplyBodyFail;
+    MessageParcel replyBodyFail;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBodyFail));
+    EXPECT_EQ(SC_OK,
+        secCompService_->RegisterSecurityComponent(rawdataBodyFail, rawReplyBodyFail));
+    SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyBodyFail, replyBodyFail);
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, replyBodyFail.ReadInt32());
+    data.FlushBuffer();
+
+    // RegisterSecurityComponent OK
+    nlohmann::json jsonRes;
+    ServiceTestCommon::BuildSaveComponentJson(jsonRes);
+    std::string saveInfo = jsonRes.dump();
+    uintType = SAVE_COMPONENT;
+    data.WriteUint32(uintType);
+    data.WriteString(saveInfo);
+    SecCompRawdata rawdata;
+    SecCompRawdata rawReply;
+    MessageParcel reply;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->RegisterSecurityComponent(rawdata, rawReply));
+    SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply);
+    EXPECT_EQ(SC_OK, reply.ReadInt32());
+}
+
+/**
+ * @tc.name: UpdateReadFromRawdata001
+ * @tc.desc: Test UpdateReadFromRawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UpdateReadFromRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+    int32_t scIdOut;
+    std::string componentInfoOut;
+
+    // rawdata.data is nullptr
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
+        secCompService_->UpdateReadFromRawdata(rawdataVoid, scIdOut, componentInfoOut));
+
+    // scId is invalid
+    data.WriteInt32(-1);
+    SecCompRawdata rawdataScidInvalid;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataScidInvalid));
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
+        secCompService_->UpdateReadFromRawdata(rawdataScidInvalid, scIdOut, componentInfoOut));
+    data.FlushBuffer();
+
+    // UpdateReadFromRawdata OK
+    data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
+    data.WriteString("");
+    SecCompRawdata rawdata;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->UpdateReadFromRawdata(rawdata, scIdOut, componentInfoOut));
+    data.FlushBuffer();
+}
+
+/**
+ * @tc.name: UpdateWriteToRawdata001
+ * @tc.desc: Test UpdateWriteToRawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UpdateWriteToRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    SecCompRawdata rawReply;
+    EXPECT_EQ(SC_OK,
+        secCompService_->UpdateWriteToRawdata(SC_OK, rawReply));
+}
+
+/**
+ * @tc.name: UpdateSecurityComponent001
+ * @tc.desc: Test UpdateSecurityComponent fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UpdateSecurityComponent001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+
+    // UpdateReadFromRawdata from fail
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    SecCompRawdata rawReplyVoid;
+    MessageParcel replyVoid;
+    EXPECT_EQ(SC_OK,
+        secCompService_->UpdateSecurityComponent(rawdataVoid, rawReplyVoid));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
+
+    // UpdateSecurityComponentBody fail
+    SecCompRawdata rawdataBodyFail;
+    SecCompRawdata rawReplyBodyFail;
+    MessageParcel replyBodyFail;
+    data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
+    data.WriteString("");
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBodyFail));
+    EXPECT_EQ(SC_OK,
+        secCompService_->UpdateSecurityComponent(rawdataBodyFail, rawReplyBodyFail));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyBodyFail, replyBodyFail));
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, replyBodyFail.ReadInt32());
+    data.FlushBuffer();
+}
+
+/**
+ * @tc.name: UpdateSecurityComponent002
+ * @tc.desc: Test UpdateSecurityComponent OK
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UpdateSecurityComponent002, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+    nlohmann::json jsonRes;
+    ServiceTestCommon::BuildLocationComponentJson(jsonRes);
+    std::string locationInfo = jsonRes.dump();
+    int32_t scId;
+    EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(
+        LOCATION_COMPONENT, locationInfo, scId));
+
+    SecCompRawdata rawdata;
+    SecCompRawdata rawReply;
+    MessageParcel reply;
+    data.WriteInt32(scId);
+    data.WriteString(locationInfo);
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->UpdateSecurityComponent(rawdata, rawReply));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
+    EXPECT_EQ(SC_OK, reply.ReadInt32());
+}
+
+/**
+ * @tc.name: UnregisterReadFromRawdata001
+ * @tc.desc: Test UnregisterReadFromRawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UnregisterReadFromRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+    int32_t scIdOut;
+    std::string componentInfoOut;
+
+    // rawdata.data is nullptr
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
+        secCompService_->UnregisterReadFromRawdata(rawdataVoid, scIdOut));
+
+    // scId is invalid
+    data.WriteInt32(-1);
+    SecCompRawdata rawdataScidInvalid;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataScidInvalid));
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID,
+        secCompService_->UnregisterReadFromRawdata(rawdataScidInvalid, scIdOut));
+    data.FlushBuffer();
+
+    // UpdateReadFromRawdata OK
+    data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
+    SecCompRawdata rawdata;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->UnregisterReadFromRawdata(rawdata, scIdOut));
+    EXPECT_EQ(ServiceTestCommon::TEST_SC_ID_1, scIdOut);
+    data.FlushBuffer();
+}
+
+/**
+ * @tc.name: UnregisterWriteToRawdata001
+ * @tc.desc: Test UnregisterWriteToRawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UnregisterWriteToRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    SecCompRawdata rawReply;
+    EXPECT_EQ(SC_OK,
+        secCompService_->UnregisterWriteToRawdata(SC_OK, rawReply));
+}
+
+/**
+ * @tc.name: UnregisterSecurityComponent001
+ * @tc.desc: Test UnregisterSecurityComponent fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UnregisterSecurityComponent001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+
+    // UnregisterReadFromRawdata fail
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    SecCompRawdata rawReplyVoid;
+    MessageParcel replyVoid;
+    EXPECT_EQ(SC_OK,
+        secCompService_->UnregisterSecurityComponent(rawdataVoid, rawReplyVoid));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
+
+    // UpdateSecurityComponentBody fail
+    SecCompRawdata rawdataBodyFail;
+    SecCompRawdata rawReplyBodyFail;
+    MessageParcel replyBodyFail;
+    data.WriteInt32(ServiceTestCommon::TEST_SC_ID_1);
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataBodyFail));
+    EXPECT_EQ(SC_OK,
+        secCompService_->UnregisterSecurityComponent(rawdataBodyFail, rawReplyBodyFail));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyBodyFail, replyBodyFail));
+    EXPECT_EQ(SC_SERVICE_ERROR_COMPONENT_NOT_EXIST, replyBodyFail.ReadInt32());
+}
+
+/**
+ * @tc.name: UnregisterSecurityComponent002
+ * @tc.desc: Test UnregisterSecurityComponent OK
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, UnregisterSecurityComponent002, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+    nlohmann::json jsonRes;
+    ServiceTestCommon::BuildLocationComponentJson(jsonRes);
+    std::string locationInfo = jsonRes.dump();
+    int32_t scId;
+    EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(
+        LOCATION_COMPONENT, locationInfo, scId));
+
+    SecCompRawdata rawdata;
+    SecCompRawdata rawReply;
+    MessageParcel reply;
+    data.WriteInt32(scId);
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->UnregisterSecurityComponent(rawdata, rawReply));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
+    EXPECT_EQ(SC_OK, reply.ReadInt32());
+}
+
+/**
+ * @tc.name: PreRegisterReadFromRawdata001
+ * @tc.desc: Test PreRegisterReadFromRawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, PreRegisterReadFromRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+
+    // rawdata.data is nullptr
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL,
+        secCompService_->PreRegisterReadFromRawdata(rawdataVoid));
+
+    // PreRegisterReadFromRawdata OK
+    SecCompRawdata rawdata;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->PreRegisterReadFromRawdata(rawdata));
+}
+
+/**
+ * @tc.name: PreRegisterWriteToRawdata001
+ * @tc.desc: Test PreRegisterWriteToRawdata
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, PreRegisterWriteToRawdata001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    SecCompRawdata rawReply;
+    EXPECT_EQ(SC_OK,
+        secCompService_->PreRegisterWriteToRawdata(SC_OK, rawReply));
+}
+
+/**
+ * @tc.name: PreRegisterSecCompProcess001
+ * @tc.desc: Test PreRegisterSecCompProcess
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, PreRegisterSecCompProcess001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+
+    // UnregisterReadFromRawdata fail
+    SecCompRawdata rawdataVoid;
+    rawdataVoid.size = 1;
+    SecCompRawdata rawReplyVoid;
+    MessageParcel replyVoid;
+    EXPECT_EQ(SC_OK,
+        secCompService_->PreRegisterSecCompProcess(rawdataVoid, rawReplyVoid));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
+
+    // UnregisterReadFromRawdata OK
+    SecCompRawdata rawdata;
+    SecCompRawdata rawReply;
+    MessageParcel reply;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->PreRegisterSecCompProcess(rawdata, rawReply));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
+    EXPECT_EQ(SC_OK, reply.ReadInt32());
+}
+
+/**
+ * @tc.name: ReportSecurityComponentClickEventBody001
+ * @tc.desc: Test register security component
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEventBody001, TestSize.Level1)
 {
     int32_t scId;
     secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
@@ -274,7 +719,7 @@ HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEvent001, TestSize.
  */
 HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEventBody002, TestSize.Level1)
 {
-    SC_LOG_INFO(LABEL, "ReportSecurityComponentClickEvent002");
+    SC_LOG_INFO(LABEL, "ReportSecurityComponentClickEventBody002");
     int32_t scId;
     secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
     secCompService_->Initialize();
@@ -325,3 +770,91 @@ HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEventBody002, TestS
     ASSERT_NE(AccessTokenKit::VerifyAccessToken(ServiceTestCommon::HAP_TOKEN_ID,
         "ohos.permission.APPROXIMATELY_LOCATION"), 0);
 }
+
+/**
+ * @tc.name: ReportSecurityComponentClickEvent001
+ * @tc.desc: Test ReportSecurityComponentClickEvent read rawData fail
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEvent001, TestSize.Level1)
+{
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    MessageParcel data;
+
+    // rawdata.data is nullptr
+    SecCompRawdata rawdataVoid;
+    SecCompRawdata rawReplyVoid;
+    MessageParcel replyVoid;
+    EXPECT_EQ(SC_OK,
+        secCompService_->ReportSecurityComponentClickEvent(nullptr, nullptr, rawdataVoid, rawReplyVoid));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyVoid, replyVoid));
+    EXPECT_EQ(SC_SERVICE_ERROR_PARCEL_OPERATE_FAIL, replyVoid.ReadInt32());
+
+    // scId is invalid
+    data.WriteInt32(-1);
+    SecCompRawdata rawdataScidInvalid;
+    SecCompRawdata rawReplyScidInvalid;
+    MessageParcel replyScidInvalid;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdataScidInvalid));
+    EXPECT_EQ(SC_OK,
+        secCompService_->ReportSecurityComponentClickEvent(nullptr, nullptr, rawdataScidInvalid, rawReplyScidInvalid));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReplyScidInvalid, replyScidInvalid));
+    EXPECT_EQ(SC_SERVICE_ERROR_VALUE_INVALID, replyScidInvalid.ReadInt32());
+}
+
+/**
+ * @tc.name: ReportSecurityComponentClickEvent002
+ * @tc.desc: Test ReportSecurityComponentClickEvent OK
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SecCompServiceMockTest, ReportSecurityComponentClickEvent002, TestSize.Level1)
+{
+    int32_t scId;
+    secCompService_->state_ = ServiceRunningState::STATE_RUNNING;
+    secCompService_->Initialize();
+    nlohmann::json jsonRes;
+    ServiceTestCommon::BuildLocationComponentJson(jsonRes);
+    std::string locationInfo = jsonRes.dump();
+
+    ASSERT_EQ(0, SetSelfTokenID(ServiceTestCommon::HAP_TOKEN_ID));
+    AppExecFwk::AppStateData stateData = {
+        .uid = getuid()
+    };
+    secCompService_->appStateObserver_->AddProcessToForegroundSet(stateData);
+    // register security component ok
+    EXPECT_EQ(SC_OK, secCompService_->RegisterSecurityComponentBody(LOCATION_COMPONENT, locationInfo, scId));
+    uint8_t buffer[1] = { 0 };
+    struct SecCompClickEvent clickInfo1 = {
+        .type = ClickEventType::POINT_EVENT_TYPE,
+        .point.touchX = 100,
+        .point.touchY = 100,
+        .point.timestamp =
+            static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) /
+            ServiceTestCommon::TIME_CONVERSION_UNIT,
+        .extraInfo = {
+            .data = buffer,
+            .dataSize = 1
+        },
+    };
+    SecCompInfo secCompInfo{ scId, locationInfo, clickInfo1 };
+
+    MessageParcel data;
+    data.WriteInt32(scId);
+    data.WriteString(locationInfo);
+    sptr<SecCompClickEventParcel> parcel = new (std::nothrow) SecCompClickEventParcel();
+    ASSERT_NE(nullptr, parcel);
+    parcel->clickInfoParams_ = clickInfo1;
+    data.WriteParcelable(parcel);
+
+    SecCompRawdata rawdata;
+    SecCompRawdata rawReply;
+    MessageParcel reply;
+    EXPECT_EQ(true, SecCompEnhanceAdapter::EnhanceSrvSerialize(data, rawdata));
+    EXPECT_EQ(SC_OK,
+        secCompService_->ReportSecurityComponentClickEvent(nullptr, nullptr, rawdata, rawReply));
+    ASSERT_TRUE(SecCompEnhanceAdapter::EnhanceSrvDeserialize(rawReply, reply));
+    EXPECT_EQ(SC_OK, reply.ReadInt32());
+}
\ No newline at end of file