diff --git a/interfaces/innerkits/sandbox_manager/include/sandbox_manager_proxy.h b/interfaces/innerkits/sandbox_manager/include/sandbox_manager_proxy.h
index ebce0a2a027e6f996f44a0111b14f063c01a5bd2..0b7cd062574f4f05affa8f835553d44e65c451e2 100644
--- a/interfaces/innerkits/sandbox_manager/include/sandbox_manager_proxy.h
+++ b/interfaces/innerkits/sandbox_manager/include/sandbox_manager_proxy.h
@@ -45,7 +45,9 @@ public:
         uint64_t tokenId, const std::vector<PolicyInfo> &policy, std::vector<uint32_t> &result) override;
 
 private:
-    bool SendRequest(SandboxManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply);
+    int32_t SendRequest(SandboxManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply);
+    int32_t SendRequest(SandboxManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply,
+                        MessageOption &option);
     static inline BrokerDelegator<SandboxManagerProxy> delegator_;
 };
 } // namespace SandboxManager
diff --git a/interfaces/innerkits/sandbox_manager/src/sandbox_manager_proxy.cpp b/interfaces/innerkits/sandbox_manager/src/sandbox_manager_proxy.cpp
index 52a625ad33546c5417dc34830edbdb27d1248b63..58c5b96d543c6cd5e8198965e5a231ed9b2f0720 100644
--- a/interfaces/innerkits/sandbox_manager/src/sandbox_manager_proxy.cpp
+++ b/interfaces/innerkits/sandbox_manager/src/sandbox_manager_proxy.cpp
@@ -41,22 +41,25 @@ SandboxManagerProxy::SandboxManagerProxy(const sptr<IRemoteObject> &impl)
 SandboxManagerProxy::~SandboxManagerProxy()
 {}
 
-bool SandboxManagerProxy::SendRequest(SandboxManagerInterfaceCode code,
-    MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerProxy::SendRequest(SandboxManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply)
 {
     MessageOption option(MessageOption::TF_SYNC);
+    return SendRequest(code, data, reply, option);
+}
+
+int32_t SandboxManagerProxy::SendRequest(SandboxManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply,
+    MessageOption &option)
+{
     sptr<IRemoteObject> remote = Remote();
     if (remote == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote service null.");
-        return false;
+        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
     }
-    int32_t requestResult = remote->SendRequest(
-        static_cast<uint32_t>(code), data, reply, option);
-    if (requestResult != NO_ERROR) {
+    int32_t requestResult = remote->SendRequest(static_cast<uint32_t>(code), data, reply, option);
+    if (requestResult != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "request fail, result: %{public}d", requestResult);
-        return false;
     }
-    return true;
+    return requestResult;
 }
 
 int32_t SandboxManagerProxy::PersistPolicy(const std::vector<PolicyInfo> &policy, std::vector<uint32_t> &result)
@@ -73,11 +76,12 @@ int32_t SandboxManagerProxy::PersistPolicy(const std::vector<PolicyInfo> &policy
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policyInfoVectorParcel fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     MessageParcel reply;
-    if (!SendRequest(SandboxManagerInterfaceCode::PERSIST_PERMISSION, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::PERSIST_PERMISSION, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -109,9 +113,10 @@ int32_t SandboxManagerProxy::UnPersistPolicy(const std::vector<PolicyInfo> &poli
     }
     
     MessageParcel reply;
-    if (!SendRequest(SandboxManagerInterfaceCode::UNPERSIST_PERMISSION, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::UNPERSIST_PERMISSION, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -148,9 +153,10 @@ int32_t SandboxManagerProxy::PersistPolicyByTokenId(
     }
     
     MessageParcel reply;
-    if (!SendRequest(SandboxManagerInterfaceCode::PERSIST_PERMISSION_BY_TOKENID, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::PERSIST_PERMISSION_BY_TOKENID, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -186,9 +192,10 @@ int32_t SandboxManagerProxy::UnPersistPolicyByTokenId(
     }
     
     MessageParcel reply;
-    if (!SendRequest(SandboxManagerInterfaceCode::UNPERSIST_PERMISSION_BY_TOKENID, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::UNPERSIST_PERMISSION_BY_TOKENID, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -230,10 +237,10 @@ int32_t SandboxManagerProxy::SetPolicy(uint64_t tokenId, const std::vector<Polic
     }
 
     MessageParcel reply;
-    MessageOption option(MessageOption::TF_SYNC);
-    if (!SendRequest(SandboxManagerInterfaceCode::SET_POLICY, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::SET_POLICY, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -260,10 +267,10 @@ int32_t SandboxManagerProxy::StartAccessingPolicy(const std::vector<PolicyInfo>
     }
     
     MessageParcel reply;
-    MessageOption option(MessageOption::TF_SYNC);
-    if (!SendRequest(SandboxManagerInterfaceCode::START_ACCESSING_URI, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::START_ACCESSING_URI, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -295,10 +302,10 @@ int32_t SandboxManagerProxy::StopAccessingPolicy(const std::vector<PolicyInfo> &
     }
     
     MessageParcel reply;
-    MessageOption option(MessageOption::TF_SYNC);
-    if (!SendRequest(SandboxManagerInterfaceCode::STOP_ACCESSING_URI, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::STOP_ACCESSING_URI, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
@@ -335,10 +342,10 @@ int32_t SandboxManagerProxy::CheckPersistPolicy(uint64_t tokenId, const std::vec
     }
 
     MessageParcel reply;
-    MessageOption option(MessageOption::TF_SYNC);
-    if (!SendRequest(SandboxManagerInterfaceCode::CHECK_PERSIST_PERMISSION, data, reply)) {
+    int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::CHECK_PERSIST_PERMISSION, data, reply);
+    if (requestRet != SANDBOX_MANAGER_OK) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "remote fail");
-        return SANDBOX_MANAGER_SERVICE_REMOTE_ERR;
+        return requestRet;
     }
 
     int32_t remoteRet;
diff --git a/services/sandbox_manager/main/cpp/include/service/sandbox_manager_stub.h b/services/sandbox_manager/main/cpp/include/service/sandbox_manager_stub.h
index 97d01919b238a32f968ebe75af857d14bc528ca7..c4509ec0492f00c63efca928b2ba0fff5dcc97ba 100644
--- a/services/sandbox_manager/main/cpp/include/service/sandbox_manager_stub.h
+++ b/services/sandbox_manager/main/cpp/include/service/sandbox_manager_stub.h
@@ -36,19 +36,19 @@ public:
     virtual void DelayUnloadService() = 0;
 
 private:
-    void PersistPolicyInner(MessageParcel &data, MessageParcel &reply);
-    void UnPersistPolicyInner(MessageParcel &data, MessageParcel &reply);
-    void PersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply);
-    void UnPersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply);
-    void SetPolicyInner(MessageParcel &data, MessageParcel &reply);
-    void StartAccessingPolicyInner(MessageParcel &data, MessageParcel &reply);
-    void StopAccessingPolicyInner(MessageParcel &data, MessageParcel &reply);
-    void CheckPersistPolicyInner(MessageParcel &data, MessageParcel &reply);
+    int32_t PersistPolicyInner(MessageParcel &data, MessageParcel &reply);
+    int32_t UnPersistPolicyInner(MessageParcel &data, MessageParcel &reply);
+    int32_t PersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply);
+    int32_t UnPersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply);
+    int32_t SetPolicyInner(MessageParcel &data, MessageParcel &reply);
+    int32_t StartAccessingPolicyInner(MessageParcel &data, MessageParcel &reply);
+    int32_t StopAccessingPolicyInner(MessageParcel &data, MessageParcel &reply);
+    int32_t CheckPersistPolicyInner(MessageParcel &data, MessageParcel &reply);
     void SetPolicyOpFuncInMap();
 
     bool CheckPermission(const uint64_t tokenId, const std::string &permission);
 
-    using RequestFuncType = void (SandboxManagerStub::*)(MessageParcel &data, MessageParcel &reply);
+    using RequestFuncType = int32_t (SandboxManagerStub::*)(MessageParcel &data, MessageParcel &reply);
     std::map<uint32_t, RequestFuncType> requestFuncMap_;
 };
 } // namespace SandboxManager
diff --git a/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp b/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp
index e017a0f7d0aafd35734d8312c7805de3c5ef255b..90f4ae9b1f619a787b5640c57cb5313ceb1a7941 100644
--- a/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp
+++ b/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp
@@ -54,7 +54,7 @@ int32_t SandboxManagerStub::OnRemoteRequest(
     if (itFunc != requestFuncMap_.end()) {
         auto requestFunc = itFunc->second;
         if (requestFunc != nullptr) {
-            (this->*requestFunc)(data, reply);
+            return (this->*requestFunc)(data, reply);
         } else {
             // when valid code without any function to handle
             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
@@ -66,287 +66,260 @@ int32_t SandboxManagerStub::OnRemoteRequest(
     return NO_ERROR;
 }
 
-void SandboxManagerStub::PersistPolicyInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::PersistPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, ACCESS_PERSIST_PERMISSION_NAME)) {
-        reply.WriteInt32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
 
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     std::vector<uint32_t> result;
     int32_t ret = this->PersistPolicy(policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteUInt32Vector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager vector parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::UnPersistPolicyInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::UnPersistPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, ACCESS_PERSIST_PERMISSION_NAME)) {
-        reply.WriteInt32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
 
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "read sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     std::vector<uint32_t> result;
-    
+
     int32_t ret = this->UnPersistPolicy(policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteUInt32Vector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager vector parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::PersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::PersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, ACCESS_PERSIST_PERMISSION_NAME)) {
-        reply.WriteInt32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
     uint64_t tokenId;
     if (!data.ReadUint64(tokenId)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "read tokenId parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "read sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     std::vector<uint32_t> result;
     int32_t ret = this->PersistPolicyByTokenId(tokenId, policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteUInt32Vector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager vector parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::UnPersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::UnPersistPolicyByTokenIdInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, ACCESS_PERSIST_PERMISSION_NAME)) {
-        reply.WriteUint32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
     uint64_t tokenId;
     if (!data.ReadUint64(tokenId)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply tokenId parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     std::vector<uint32_t> result;
-    
+
     int32_t ret = this->UnPersistPolicyByTokenId(tokenId, policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteUInt32Vector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager vector parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::SetPolicyInner(MessageParcel &data, MessageParcel &reply)
+
+int32_t SandboxManagerStub::SetPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, SET_POLICY_PERMISSION_NAME)) {
-        reply.WriteUint32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
 
     uint64_t tokenId;
     if (!data.ReadUint64(tokenId)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply tokenId parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
     uint64_t policyFlag;
     if (!data.ReadUint64(policyFlag)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "read policyFlag parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     int32_t ret = this->SetPolicy(tokenId, policyInfoVectorParcel->policyVector, policyFlag);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::StartAccessingPolicyInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::StartAccessingPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, ACCESS_PERSIST_PERMISSION_NAME)) {
-        reply.WriteInt32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
 
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     std::vector<uint32_t> result;
     int32_t ret = this->StartAccessingPolicy(policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteUInt32Vector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Write sandbox manager reply parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::StopAccessingPolicyInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::StopAccessingPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t callingTokenId = IPCSkeleton::GetCallingTokenID();
     if (!CheckPermission(callingTokenId, ACCESS_PERSIST_PERMISSION_NAME)) {
-        reply.WriteInt32(PERMISSION_DENIED);
-        return;
+        return PERMISSION_DENIED;
     }
 
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    
+
     std::vector<uint32_t> result;
-    
+
     int32_t ret = this->StopAccessingPolicy(policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteUInt32Vector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Write sandbox manager reply parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
-void SandboxManagerStub::CheckPersistPolicyInner(MessageParcel &data, MessageParcel &reply)
+int32_t SandboxManagerStub::CheckPersistPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint64_t tokenId;
     if (!data.ReadUint64(tokenId)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply tokenId parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel = data.ReadParcelable<PolicyInfoVectorParcel>();
     if (policyInfoVectorParcel == nullptr) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager data parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
     std::vector<bool> result;
     int32_t ret = this->CheckPersistPolicy(tokenId, policyInfoVectorParcel->policyVector, result);
     if (!reply.WriteInt32(ret)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "reply sandbox manager ret parcel fail");
-        reply.WriteInt32(SANDBOX_MANAGER_SERVICE_PARCEL_ERR);
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     if (ret != SANDBOX_MANAGER_OK) {
-        return;
+        return ret;
     }
 
     if (!reply.WriteBoolVector(result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Write sandbox manager reply parcel fail");
-        return;
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    return;
+    return SANDBOX_MANAGER_OK;
 }
 
 void SandboxManagerStub::SetPolicyOpFuncInMap()
diff --git a/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp b/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp
index 454f782e93ef3cf35c2d5e4b19bff5fa261fa19e..e3d30140ff90c7c200da88b887dfd521fde4161e 100644
--- a/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp
+++ b/services/sandbox_manager/test/unittest/sandbox_manager_service_test.cpp
@@ -30,6 +30,7 @@
 #include "sandbox_manager_event_subscriber.h"
 #include "sandbox_manager_service.h"
 #undef private
+#include "sandboxmanager_service_ipc_interface_code.h"
 #include "token_setproc.h"
 
 using namespace testing::ext;
@@ -114,17 +115,17 @@ void SandboxManagerServiceTest::TearDownTestCase(void)
 void SandboxManagerServiceTest::SetUp(void)
 {
     sandboxManagerService_ = DelayedSingleton<SandboxManagerService>::GetInstance();
-    EXPECT_NE(nullptr, sandboxManagerService_);
+    ASSERT_NE(nullptr, sandboxManagerService_);
 
     selfTokenId_ = GetSelfTokenID();
     NativeTokenGet();
     Security::AccessToken::AccessTokenID tokenID =
         Security::AccessToken::AccessTokenKit::GetNativeTokenId("foundation");
-    EXPECT_NE(0, tokenID);
+    ASSERT_NE(0, tokenID);
     EXPECT_EQ(0, SetSelfTokenID(tokenID));
     Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
     tokenIdEx = Security::AccessToken::AccessTokenKit::AllocHapToken(g_testInfoParms, g_testPolicyPrams);
-    EXPECT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
+    ASSERT_NE(0, tokenIdEx.tokenIdExStruct.tokenID);
     sysGrantToken_ = tokenIdEx.tokenIdExStruct.tokenID;
 }
 
@@ -284,8 +285,8 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerServiceTest007, TestSize.Level
     std::vector<PolicyInfo> policy;
     std::vector<uint32_t> result;
     policy.resize(1);
-    EXPECT_NE(INVALID_PARAMTER, sandboxManagerService_->PersistPolicy(policy, result));
-    EXPECT_NE(INVALID_PARAMTER, sandboxManagerService_->UnPersistPolicy(policy, result));
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->PersistPolicy(policy, result));
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->UnPersistPolicy(policy, result));
 }
  
 /**
@@ -316,8 +317,8 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerServiceTest008, TestSize.Level
     EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->PersistPolicyByTokenId(tokenId, policy, result));
     EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->UnPersistPolicyByTokenId(tokenId, policy, result));
     tokenId = 1;
-    EXPECT_NE(INVALID_PARAMTER, sandboxManagerService_->PersistPolicyByTokenId(tokenId, policy, result));
-    EXPECT_NE(INVALID_PARAMTER, sandboxManagerService_->UnPersistPolicyByTokenId(tokenId, policy, result));
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->PersistPolicyByTokenId(tokenId, policy, result));
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->UnPersistPolicyByTokenId(tokenId, policy, result));
 }
  
 /**
@@ -402,31 +403,26 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub001, TestSize.Level1)
     MessageOption option;
     std::string descriptor = "I don't know";
     data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor));
-    EXPECT_NE(NO_ERROR, sandboxManagerService_->OnRemoteRequest(code, data, reply, option));
+    EXPECT_EQ(-1, sandboxManagerService_->OnRemoteRequest(code, data, reply, option));
     data.WriteInterfaceToken(u"ohos.accesscontrol.sandbox_manager.ISandboxManager");
     EXPECT_NE(NO_ERROR, sandboxManagerService_->OnRemoteRequest(code, data, reply, option));
     data.WriteInterfaceToken(u"ohos.accesscontrol.sandbox_manager.ISandboxManager");
-    code = 0xffb0;
-    EXPECT_EQ(NO_ERROR, sandboxManagerService_->OnRemoteRequest(code, data, reply, option));
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->OnRemoteRequest(
+        static_cast<uint32_t>(SandboxManagerInterfaceCode::PERSIST_PERMISSION), data, reply, option));
 
     sandboxManagerService_->requestFuncMap_.insert(
         std::pair<uint32_t, SandboxManagerStub::RequestFuncType>(code, nullptr));
-    ASSERT_NE(sandboxManagerService_->requestFuncMap_.end(),
-        sandboxManagerService_->requestFuncMap_.find(code));
+    ASSERT_NE(sandboxManagerService_->requestFuncMap_.end(), sandboxManagerService_->requestFuncMap_.find(code));
     data.WriteInterfaceToken(u"ohos.accesscontrol.sandbox_manager.ISandboxManager");
-    EXPECT_EQ(NO_ERROR, sandboxManagerService_->OnRemoteRequest(code, data, reply, option));
+    EXPECT_NE(NO_ERROR, sandboxManagerService_->OnRemoteRequest(code, data, reply, option));
     sandboxManagerService_->requestFuncMap_.erase(code);
 
-    sandboxManagerService_->PersistPolicyInner(data, reply);
-    int32_t ret = reply.ReadInt32();
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, ret);
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyInner(data, reply));
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel;
     data.WriteParcelable(policyInfoVectorParcel);
     sandboxManagerService_->PersistPolicyInner(data, reply);
 
-    sandboxManagerService_->UnPersistPolicyInner(data, reply);
-    ret = reply.ReadInt32();
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, ret);
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyInner(data, reply));
     data.WriteParcelable(policyInfoVectorParcel);
     sandboxManagerService_->UnPersistPolicyInner(data, reply);
     uint64_t tokenId = 0;
@@ -443,26 +439,20 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub002, TestSize.Level1)
 {
     MessageParcel data;
     MessageParcel reply;
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
     data.WriteUint64(1);
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
     data.WriteUint64(1);
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel;
     data.WriteParcelable(policyInfoVectorParcel);
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
 
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply));
     data.WriteUint64(1);
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply));
     data.WriteUint64(1);
     data.WriteParcelable(policyInfoVectorParcel);
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply));
 }
 
 /**
@@ -475,46 +465,34 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub003, TestSize.Level1)
 {
     MessageParcel data;
     MessageParcel reply;
-    sandboxManagerService_->SetPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->SetPolicyInner(data, reply));
     data.WriteUint64(1);
-    sandboxManagerService_->SetPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->SetPolicyInner(data, reply));
     data.WriteUint64(1);
     sptr<PolicyInfoVectorParcel> policyInfoVectorParcel;
     data.WriteParcelable(policyInfoVectorParcel);
-    sandboxManagerService_->SetPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->SetPolicyInner(data, reply));
 
-    sandboxManagerService_->CheckPersistPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->CheckPersistPolicyInner(data, reply));
     data.WriteUint64(1);
-    sandboxManagerService_->CheckPersistPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->CheckPersistPolicyInner(data, reply));
     data.WriteUint64(1);
     data.WriteParcelable(policyInfoVectorParcel);
-    sandboxManagerService_->CheckPersistPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->CheckPersistPolicyInner(data, reply));
 
-    sandboxManagerService_->StartAccessingPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->StartAccessingPolicyInner(data, reply));
     data.WriteUint64(1);
-    sandboxManagerService_->StartAccessingPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->StartAccessingPolicyInner(data, reply));
     data.WriteUint64(1);
     data.WriteParcelable(policyInfoVectorParcel);
-    sandboxManagerService_->StartAccessingPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->StartAccessingPolicyInner(data, reply));
 
-    sandboxManagerService_->StopAccessingPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->StopAccessingPolicyInner(data, reply));
     data.WriteUint64(1);
-    sandboxManagerService_->StopAccessingPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->StopAccessingPolicyInner(data, reply));
     data.WriteUint64(1);
     data.WriteParcelable(policyInfoVectorParcel);
-    sandboxManagerService_->StopAccessingPolicyInner(data, reply);
-    EXPECT_NE(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->StopAccessingPolicyInner(data, reply));
 }
 
 /**
@@ -528,8 +506,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub004, TestSize.Level1)
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->PersistPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyInner(data, reply));
 
     std::vector<PolicyInfo> policy;
     policy.emplace_back(PolicyInfo {
@@ -539,8 +516,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub004, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->PersistPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->PersistPolicyInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -554,12 +530,10 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub005, TestSize.Level1)
 {
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
-    sandboxManagerService_->UnPersistPolicyInner(data, reply); // no tokenid
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyInner(data, reply));
 
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->UnPersistPolicyInner(data, reply); // err read parcel
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyInner(data, reply));
 
     std::vector<PolicyInfo> policy;
     policy.emplace_back(PolicyInfo {
@@ -569,8 +543,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub005, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->UnPersistPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->UnPersistPolicyInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -584,13 +557,11 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub006, TestSize.Level1)
 {
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply); // no tokenid
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
 
     data.WriteUint64(0);
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply); // err read parcel
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
 
     data.WriteUint64(0);
     std::vector<PolicyInfo> policy;
@@ -601,8 +572,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub006, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply); // err path
-    EXPECT_EQ(INVALID_PARAMTER, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
 
     data.WriteUint64(1);
     policy.clear();
@@ -612,8 +582,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub006, TestSize.Level1)
     });
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -627,13 +596,11 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub007, TestSize.Level1)
 {
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply); // no tokenid
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply));
 
     data.WriteUint64(0);
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply); // err read parcel
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply));
 
     data.WriteUint64(0);
     std::vector<PolicyInfo> policy;
@@ -644,8 +611,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub007, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply);
-    EXPECT_EQ(INVALID_PARAMTER, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply));
 
     data.WriteUint64(1);
     policy.clear();
@@ -655,8 +621,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub007, TestSize.Level1)
     });
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->PersistPolicyByTokenIdInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -670,13 +635,11 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub008, TestSize.Level1)
 {
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
-    sandboxManagerService_->SetPolicyInner(data, reply); // no tokenid
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->SetPolicyInner(data, reply));
 
     data.WriteUint64(sysGrantToken_);
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->SetPolicyInner(data, reply); // err read parcel
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->SetPolicyInner(data, reply));
 
     data.WriteUint64(sysGrantToken_);
     std::vector<PolicyInfo> policy;
@@ -688,8 +651,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub008, TestSize.Level1)
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
     data.WriteUint64(0);
-    sandboxManagerService_->SetPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->SetPolicyInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -704,8 +666,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub009, TestSize.Level1)
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->StartAccessingPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->StartAccessingPolicyInner(data, reply));
 
     std::vector<PolicyInfo> policy;
     policy.emplace_back(PolicyInfo {
@@ -715,8 +676,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub009, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->StartAccessingPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->StartAccessingPolicyInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -731,8 +691,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub010, TestSize.Level1)
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply;
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->StopAccessingPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->StopAccessingPolicyInner(data, reply));
 
     std::vector<PolicyInfo> policy;
     policy.emplace_back(PolicyInfo {
@@ -742,8 +701,7 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub010, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->StopAccessingPolicyInner(data, reply);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->StopAccessingPolicyInner(data, reply));
     SetSelfTokenID(selfTokenId_);
 }
 
@@ -757,14 +715,12 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub011, TestSize.Level1)
 {
     SetSelfTokenID(sysGrantToken_);
     MessageParcel data, reply1;
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply1); // no tokenid
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply1.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply1));
 
     MessageParcel reply2;
     data.WriteUint64(0);
     data.WriteUint32(POLICY_VECTOR_SIZE_LIMIT + 1);
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply2); // err read parcel
-    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, reply2.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_SERVICE_PARCEL_ERR, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply2));
 
     MessageParcel reply3;
     data.WriteUint64(1);
@@ -776,14 +732,12 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub011, TestSize.Level1)
     PolicyInfoVectorParcel policyInfoVectorParcel;
     policyInfoVectorParcel.policyVector = policy;
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply3);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply3.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->UnPersistPolicyByTokenIdInner(data, reply3));
 
     MessageParcel reply4;
     data.WriteUint64(1);
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->CheckPersistPolicyInner(data, reply4);
-    EXPECT_EQ(SANDBOX_MANAGER_OK, reply4.ReadInt32());
+    EXPECT_EQ(SANDBOX_MANAGER_OK, sandboxManagerService_->CheckPersistPolicyInner(data, reply4));
 
     SetSelfTokenID(selfTokenId_);
 }
@@ -803,20 +757,16 @@ HWTEST_F(SandboxManagerServiceTest, SandboxManagerStub012, TestSize.Level1)
     MessageParcel data, reply;
 
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->PersistPolicyInner(data, reply);
-    EXPECT_EQ(INVALID_PARAMTER, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->PersistPolicyInner(data, reply));
 
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->UnPersistPolicyInner(data, reply);
-    EXPECT_EQ(INVALID_PARAMTER, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->UnPersistPolicyInner(data, reply));
 
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->StartAccessingPolicyInner(data, reply);
-    EXPECT_EQ(INVALID_PARAMTER, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->StartAccessingPolicyInner(data, reply));
 
     data.WriteParcelable(&policyInfoVectorParcel);
-    sandboxManagerService_->StopAccessingPolicyInner(data, reply);
-    EXPECT_EQ(INVALID_PARAMTER, reply.ReadInt32());
+    EXPECT_EQ(INVALID_PARAMTER, sandboxManagerService_->StopAccessingPolicyInner(data, reply));
     
     SetSelfTokenID(selfTokenId_);
 }