diff --git a/services/privacymanager/src/sensitive/sensitive_resource_manager.cpp b/services/privacymanager/src/sensitive/sensitive_resource_manager.cpp
index 5e7bce3dc752124244f36fe86f275bc623eb3c89..632c8db40d643ba7b32a54f0d5da53b824a0ff95 100644
--- a/services/privacymanager/src/sensitive/sensitive_resource_manager.cpp
+++ b/services/privacymanager/src/sensitive/sensitive_resource_manager.cpp
@@ -132,8 +132,8 @@ void SensitiveResourceManager::SetGlobalSwitch(const ResourceType type, bool swi
 
 bool SensitiveResourceManager::RegisterAppStatusChangeCallback(uint32_t tokenId, OnAppStatusChangeCallback callback)
 {
-    if (callback == nullptr) {
-        ACCESSTOKEN_LOG_ERROR(LABEL, "callback could not be null.");
+    if (tokenId == 0 || callback == nullptr) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "tokenId or callback is invalid.");
         return false;
     }
     
@@ -170,15 +170,15 @@ bool SensitiveResourceManager::RegisterAppStatusChangeCallback(uint32_t tokenId,
     appStateCallbacks_.emplace_back(listener);
     appMgrProxy->RegisterApplicationStateObserver(listener);
 
-    ACCESSTOKEN_LOG_INFO(LABEL, "register callback(%{public}p),  add TokenId(%{public}d).", callback, tokenId);
+    ACCESSTOKEN_LOG_DEBUG(LABEL, "register callback(%{public}p),  add TokenId(%{public}d).", callback, tokenId);
 
     return true;
 }
 
 bool SensitiveResourceManager::UnRegisterAppStatusChangeCallback(uint32_t tokenId, OnAppStatusChangeCallback callback)
 {
-    if (callback == nullptr) {
-        ACCESSTOKEN_LOG_ERROR(LABEL, "callback could not be null.");
+    if (tokenId == 0 || callback == nullptr) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "tokenId or callback is invalid.");
         return false;
     }
     
@@ -204,7 +204,7 @@ bool SensitiveResourceManager::UnRegisterAppStatusChangeCallback(uint32_t tokenI
         appStateCallbacks_.erase(iter);
     }
     
-    ACCESSTOKEN_LOG_INFO(LABEL, "unregister callback(%{public}p).", callback);
+    ACCESSTOKEN_LOG_DEBUG(LABEL, "unregister callback(%{public}p).", callback);
 
     return true;
 }
diff --git a/services/privacymanager/src/service/privacy_manager_service.cpp b/services/privacymanager/src/service/privacy_manager_service.cpp
index 3db7543e6f8079d533121d4e6616e37cabb7a084..95d4d717cdc7e6689a1938bb026183e65f98074b 100644
--- a/services/privacymanager/src/service/privacy_manager_service.cpp
+++ b/services/privacymanager/src/service/privacy_manager_service.cpp
@@ -165,17 +165,20 @@ int32_t PrivacyManagerService::Dump(int32_t fd, const std::vector<std::u16string
     }
     int32_t ret = ERR_OK;
     dprintf(fd, "Privacy Dump:\n");
-    std::string arg0 = ((args.size() == 0) ? "" : Str16ToStr8(args.at(0)));
+    if (args.size() == 0) {
+        dprintf(fd, "please use hidumper -s said -a '-h' command help\n");
+        return ret;
+    }
+    std::string arg0 = Str16ToStr8(args.at(0));
     if (arg0.compare("-h") == 0) {
         dprintf(fd, "Usage:\n");
         dprintf(fd, "       -h: command help\n");
         dprintf(fd, "       -t <TOKEN_ID>: according to specific token id dump permission used records\n");
     } else if (arg0.compare("-t") == 0) {
         ret = PrivacyManagerService::ResponseDumpCommand(fd, args);
-    }
-
-    if (ret != ERR_OK) {
+    } else {
         dprintf(fd, "please use hidumper -s said -a '-h' command help\n");
+        ret = ERR_INVALID_VALUE;
     }
     return ret;
 }
diff --git a/services/privacymanager/test/unittest/BUILD.gn b/services/privacymanager/test/unittest/BUILD.gn
index d7178178abb7c3bd4cc35da2f0e91c75e646955c..ff66b30ccb3e0b1e974c416b5a0c3691cdc32a22 100644
--- a/services/privacymanager/test/unittest/BUILD.gn
+++ b/services/privacymanager/test/unittest/BUILD.gn
@@ -24,23 +24,32 @@ if (is_standard_system && ability_base_enable == true) {
       "//base/security/access_token/interfaces/innerkits/accesstoken/include",
       "//base/security/access_token/frameworks/privacy/include",
       "//base/security/access_token/interfaces/innerkits/privacy/include",
+      "//base/security/access_token/services/privacymanager/include/sensitive",
       "//base/security/access_token/services/privacymanager/include/service",
       "//third_party/googletest/include",
       "//commonlibrary/c_utils/base/include",
     ]
 
-    sources = [ "privacy_manager_service_test.cpp" ]
+    sources = [
+      "privacy_manager_service_test.cpp",
+      "sensitive_resource_manger_test.cpp",
+    ]
 
     configs = [ "//base/security/access_token/config:coverage_flags" ]
 
     deps = [
       "//base/security/access_token/interfaces/innerkits/accesstoken:libaccesstoken_sdk",
+      "//base/security/access_token/interfaces/innerkits/token_setproc:libtoken_setproc",
       "//base/security/access_token/services/privacymanager:privacy_manager_service",
       "//third_party/googletest:gtest_main",
     ]
 
     external_deps = [
+      "ability_runtime:app_manager",
+      "access_token:libaccesstoken_sdk",
       "c_utils:utils",
+      "ipc:ipc_core",
+      "multimedia_audio_framework:audio_client",
       "safwk:system_ability_fwk",
     ]
   }
diff --git a/services/privacymanager/test/unittest/privacy_manager_service_test.cpp b/services/privacymanager/test/unittest/privacy_manager_service_test.cpp
index 885562c1c623469b7fd2dcceb51918d410e80cae..d1ae46bf5257841cc3537ea8bddd6ccdfb1f39ee 100644
--- a/services/privacymanager/test/unittest/privacy_manager_service_test.cpp
+++ b/services/privacymanager/test/unittest/privacy_manager_service_test.cpp
@@ -13,22 +13,25 @@
  * limitations under the License.
  */
 
-#include "privacy_manager_service_test.h"
+#include <gtest/gtest.h>
+
 #include "accesstoken_kit.h"
 #include "string_ex.h"
+#include "privacy_manager_service.h"
 
 using namespace testing::ext;
-using namespace OHOS;
-using namespace OHOS::Security::AccessToken;
 
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
 namespace {
 constexpr int32_t PERMISSION_USAGE_RECORDS_MAX_NUM = 10;
 static PermissionStateFull g_testState = {
     .permissionName = "ohos.permission.CAMERA",
-    .grantFlags = {1},
-    .grantStatus = {PermissionState::PERMISSION_GRANTED},
     .isGeneral = true,
-    .resDeviceID = {"local"}
+    .resDeviceID = {"local"},
+    .grantStatus = {PermissionState::PERMISSION_GRANTED},
+    .grantFlags = {1}
 };
 
 static HapPolicyParams g_PolicyPrams = {
@@ -44,8 +47,20 @@ static HapInfoParams g_InfoParms = {
     .instIndex = 0,
     .appIDDesc = "privacy_test.bundleA"
 };
-
 }
+
+class PrivacyManagerServiceTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+
+    static void TearDownTestCase();
+
+    void SetUp();
+
+    void TearDown();
+    std::shared_ptr<PrivacyManagerService> privacyManagerService_;
+};
+
 void PrivacyManagerServiceTest::SetUpTestCase()
 {
 }
@@ -101,7 +116,12 @@ HWTEST_F(PrivacyManagerServiceTest, Dump001, TestSize.Level1)
     args.clear();
     // hidumper -t
     args.emplace_back(Str8ToStr16("-t"));
-    args.emplace_back(Str8ToStr16("-1")); // illegal tokenId // illegal tokenId
+    args.emplace_back(Str8ToStr16("-1")); // illegal tokenId
+    ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
+
+    args.clear();
+    // hidumper -t
+    args.emplace_back(Str8ToStr16("-s"));
     ASSERT_NE(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
 
     args.clear();
@@ -119,7 +139,7 @@ HWTEST_F(PrivacyManagerServiceTest, Dump001, TestSize.Level1)
  */
 HWTEST_F(PrivacyManagerServiceTest, Dump002, TestSize.Level1)
 {
-    int32_t fd = 1; // 1: std output
+    int32_t fd = 123; // 123: invalid fd
     std::vector<std::u16string> args;
     AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms.userID,
                                                           g_InfoParms.bundleName,
@@ -140,3 +160,6 @@ HWTEST_F(PrivacyManagerServiceTest, Dump002, TestSize.Level1)
     privacyManagerService_->AddPermissionUsedRecord(tokenId, permission, 1, 0);
     ASSERT_EQ(RET_SUCCESS, privacyManagerService_->Dump(fd, args));
 }
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
diff --git a/services/privacymanager/test/unittest/privacy_manager_service_test.h b/services/privacymanager/test/unittest/privacy_manager_service_test.h
deleted file mode 100644
index 6f8c016413d5399ff8eb7897621853d02bb78c31..0000000000000000000000000000000000000000
--- a/services/privacymanager/test/unittest/privacy_manager_service_test.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef PRIVACY_MANAGER_SERVICE_TEST_H
-#define PRIVACY_MANAGER_SERVICE_TEST_H
-
-#include <gtest/gtest.h>
-#include "privacy_manager_service.h"
-
-namespace OHOS {
-namespace Security {
-namespace AccessToken {
-class PrivacyManagerServiceTest : public testing::Test {
-public:
-    static void SetUpTestCase();
-
-    static void TearDownTestCase();
-
-    void SetUp();
-
-    void TearDown();
-    std::shared_ptr<PrivacyManagerService> privacyManagerService_;
-};
-} // namespace AccessToken
-} // namespace Security
-} // namespace OHOS
-#endif // PRIVACY_MANAGER_SERVICE_TEST_H
diff --git a/services/privacymanager/test/unittest/sensitive_resource_manger_test.cpp b/services/privacymanager/test/unittest/sensitive_resource_manger_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e96edfb3647a245c54776af22798bb3a7d338cff
--- /dev/null
+++ b/services/privacymanager/test/unittest/sensitive_resource_manger_test.cpp
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <cstddef>
+#include <gtest/gtest.h>
+
+#include "accesstoken_kit.h"
+#include "audio_system_manager.h"
+#include "sensitive_resource_manager.h"
+#include "token_setproc.h"
+
+using namespace testing;
+using namespace testing::ext;
+using namespace OHOS;
+using namespace OHOS::AudioStandard;
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+namespace {
+static const size_t MAX_CALLBACK_SIZE = 200;
+static uint32_t g_tokenId = 0;
+static int32_t g_status = 0;
+}
+class SensitiveResourceManagerTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp();
+    void TearDown();
+
+    uint32_t tokenId_;
+};
+
+void SensitiveResourceManagerTest::SetUpTestCase()
+{
+}
+
+void SensitiveResourceManagerTest::TearDownTestCase()
+{
+}
+
+void SensitiveResourceManagerTest::SetUp()
+{
+    tokenId_ = AccessTokenKit::GetHapTokenID(100, "com.ohos.permissionmanager", 0); // 100 is userID
+    SensitiveResourceManager::GetInstance().Init();
+}
+
+void SensitiveResourceManagerTest::TearDown()
+{
+}
+
+void AppStatusChangeCallback(uint32_t tokenId, int32_t status)
+{
+    g_tokenId = tokenId;
+    g_status = status;
+}
+
+void AppStatusChangeCallback1(uint32_t tokenId, int32_t status)
+{
+    GTEST_LOG_(INFO) << "tokenId: " << tokenId << "status: " << status;
+}
+
+/**
+ * @tc.name: RegisterAppStatusChangeCallback001
+ * @tc.desc: Test RegisterAppStatusChangeCallback with invalid parameter.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, RegisterAppStatusChangeCallback001, TestSize.Level1)
+{
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(0, AppStatusChangeCallback));
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId_, nullptr));
+}
+
+/**
+ * @tc.name: RegisterAppStatusChangeCallback002
+ * @tc.desc: Test RegisterAppStatusChangeCallback with same callback duplicate.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, RegisterAppStatusChangeCallback002, TestSize.Level1)
+{
+    uint32_t tokenId1 = 123;
+    uint32_t tokenId2 = 456;
+    ASSERT_EQ(true,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId1, AppStatusChangeCallback));
+    ASSERT_EQ(true,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId1, AppStatusChangeCallback));
+    ASSERT_EQ(true,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId2, AppStatusChangeCallback));
+    ASSERT_EQ(true,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId1, AppStatusChangeCallback1));
+    ASSERT_EQ(true,
+        SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId2, AppStatusChangeCallback1));
+    
+    SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId1, AppStatusChangeCallback);
+    SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId2, AppStatusChangeCallback);
+    SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId1, AppStatusChangeCallback1);
+    SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId2, AppStatusChangeCallback1);
+}
+
+typedef void (*AppChangeCallback)(uint32_t tokenId, int32_t status);
+std::map<uint32_t, uint32_t> g_listers;
+static bool RegisterAppStatusChangeCallbackTest(uint32_t tokenId, uint32_t cbAddr)
+{
+    AppChangeCallback callback = (AppChangeCallback)cbAddr;
+    g_listers[tokenId] = (uint32_t)callback;
+    return SensitiveResourceManager::GetInstance().RegisterAppStatusChangeCallback(tokenId, callback);
+}
+
+static bool UnregisterAppStatusChangeCallbackTest(uint32_t tokenId)
+{
+    AppChangeCallback callback = (AppChangeCallback)g_listers[tokenId];
+    return SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId, callback);
+}
+
+/**
+ * @tc.name: RegisterAppStatusChangeCallback003
+ * @tc.desc: Test RegisterAppStatusChangeCallback oversize.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, RegisterAppStatusChangeCallback003, TestSize.Level1)
+{
+    uint32_t tokenId = 1; // 1: tokenId
+    uint32_t addr = 0x12345678; // 0x12345678: simulated address
+    for (size_t i = 0; i < MAX_CALLBACK_SIZE; i++) {
+        ASSERT_EQ(true, RegisterAppStatusChangeCallbackTest(tokenId, addr));
+        tokenId++;
+        addr++;
+    }
+    ASSERT_EQ(false, RegisterAppStatusChangeCallbackTest(tokenId, addr));
+
+    tokenId = 1; // 1: tokenId
+    for (size_t i = 0; i < MAX_CALLBACK_SIZE; i++) {
+        ASSERT_EQ(true, UnregisterAppStatusChangeCallbackTest(tokenId));
+        tokenId++;
+    }
+}
+
+/**
+ * @tc.name: UnRegisterAppStatusChangeCallback001
+ * @tc.desc: Test UnRegisterAppStatusChangeCallback wit invalid parameter.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, UnRegisterAppStatusChangeCallback001, TestSize.Level1)
+{
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(0, AppStatusChangeCallback));
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId_, nullptr));
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId_, AppStatusChangeCallback));
+}
+
+/**
+ * @tc.name: UnRegisterAppStatusChangeCallback002
+ * @tc.desc: Test UnRegisterAppStatusChangeCallback wit invalid parameter.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, UnRegisterAppStatusChangeCallback002, TestSize.Level1)
+{
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(0, AppStatusChangeCallback));
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId_, nullptr));
+    ASSERT_EQ(false,
+        SensitiveResourceManager::GetInstance().UnRegisterAppStatusChangeCallback(tokenId_, AppStatusChangeCallback));
+}
+
+/**
+ * @tc.name: GetGlobalSwitchTest001
+ * @tc.desc: Verify the GetGlobalSwitch with valid ResourceType.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, GetGlobalSwitchTest001, TestSize.Level1)
+{
+    SensitiveResourceManager::GetInstance().SetGlobalSwitch(ResourceType::MICROPHONE, true);
+    usleep(500000); // 500000us = 0.5s
+    ASSERT_EQ(true, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::MICROPHONE));
+
+    SensitiveResourceManager::GetInstance().SetGlobalSwitch(ResourceType::MICROPHONE, false);
+    usleep(500000); // 500000us = 0.5s
+    ASSERT_EQ(false, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::MICROPHONE));
+}
+
+/**
+ * @tc.name: GetGlobalSwitchTest002
+ * @tc.desc: Verify the GetGlobalSwitch abnormal branch ResourceType is invalid.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, GetGlobalSwitchTest002, TestSize.Level1)
+{
+    ASSERT_EQ(true, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::INVALID));
+}
+
+/**
+ * @tc.name: SetGlobalSwitchTest001
+ * @tc.desc: Verify the SetGlobalSwitch with valid ResourceType.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, SetGlobalSwitchTest001, TestSize.Level1)
+{
+    SensitiveResourceManager::GetInstance().SetGlobalSwitch(ResourceType::CAMERA, true);
+    usleep(500000); // 500000us = 0.5s
+    ASSERT_EQ(true, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::CAMERA));
+
+    SensitiveResourceManager::GetInstance().SetGlobalSwitch(ResourceType::CAMERA, false);
+    usleep(500000); // 500000us = 0.5s
+    ASSERT_EQ(false, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::CAMERA));
+}
+
+/**
+ * @tc.name: SetGlobalSwitchTest002
+ * @tc.desc: Verify the SetGlobalSwitch abnormal branch ResourceType is invalid.
+ * @tc.type: FUNC
+ * @tc.require: issueI5RWXA issueI5RWXF
+ */
+HWTEST_F(SensitiveResourceManagerTest, SetGlobalSwitchTest002, TestSize.Level1)
+{
+    bool isMicrophoneMute = AudioStandard::AudioSystemManager::GetInstance()->IsMicrophoneMute();
+
+    SensitiveResourceManager::GetInstance().SetGlobalSwitch(ResourceType::INVALID, true);
+    usleep(500000); // 500000us = 0.5s
+    ASSERT_EQ(isMicrophoneMute, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::MICROPHONE));
+
+    SensitiveResourceManager::GetInstance().SetGlobalSwitch(ResourceType::INVALID, false);
+    usleep(500000); // 500000us = 0.5s
+    ASSERT_EQ(isMicrophoneMute, SensitiveResourceManager::GetInstance().GetGlobalSwitch(ResourceType::MICROPHONE));
+}
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS