diff --git a/test/unittest/services/src/context_pool_test.cpp b/test/unittest/services/src/context_pool_test.cpp
index 979a1713b5c541a23f098aae59721677f2771cda..5511cfadb6b09ef1e5b2597f5ef0ff1851ef8e0f 100644
--- a/test/unittest/services/src/context_pool_test.cpp
+++ b/test/unittest/services/src/context_pool_test.cpp
@@ -271,6 +271,26 @@ HWTEST_F(ContextPoolTest, StartSubscribeOsAccountSaStatusTest, TestSize.Level0)
     EXPECT_NO_THROW(ContextPool::Instance().StartSubscribeOsAccountSaStatus());
     EXPECT_NO_THROW(ContextPool::Instance().StartSubscribeOsAccountSaStatus());
 }
+
+HWTEST_F(ContextPoolTest, CancelAllTest, TestSize.Level0)
+{
+    auto context = Common::MakeShared<MockContext>();
+    EXPECT_NE(context, nullptr);
+    uint64_t contextId = 100;
+
+    EXPECT_CALL(*context, GetContextId()).WillRepeatedly(Return(contextId));
+    EXPECT_TRUE(ContextPool::Instance().Insert(context));
+    {
+        EXPECT_CALL(*context, Stop()).WillRepeatedly(Return(true));
+        EXPECT_NO_THROW(ContextPool::Instance().CancelAll());
+    }
+
+    {
+        EXPECT_CALL(*context, Stop()).WillRepeatedly(Return(false));
+        EXPECT_NO_THROW(ContextPool::Instance().CancelAll());
+    }
+    EXPECT_TRUE(ContextPool::Instance().Delete(contextId));
+}
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS
diff --git a/test/unittest/services/src/event_listener_manager_test.cpp b/test/unittest/services/src/event_listener_manager_test.cpp
index ce006934878ba8aff93eb3da62b235941324f745..1b962789947a8d75e1d360294b39a32d77ede702 100644
--- a/test/unittest/services/src/event_listener_manager_test.cpp
+++ b/test/unittest/services/src/event_listener_manager_test.cpp
@@ -74,10 +74,9 @@ HWTEST_F(EventListenerManagerTest, EventListenerManagerTestRemoveDeathRecipient_
 
 HWTEST_F(EventListenerManagerTest, EventListenerManagerTestRemoveDeathRecipient_002, TestSize.Level0)
 {
-    auto mockCallbackRemove = new MockEventListener();
+    sptr<MockEventListener> mockCallbackRemove = new MockEventListener();
     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject);
     EXPECT_CALL(*mockCallbackRemove, AsObject())
-        .WillOnce(Return(obj))
         .WillRepeatedly(Return(obj));
     
     AuthEventListenerManager& authEventListenerManager = AuthEventListenerManager::GetInstance();
@@ -86,10 +85,9 @@ HWTEST_F(EventListenerManagerTest, EventListenerManagerTestRemoveDeathRecipient_
 
 HWTEST_F(EventListenerManagerTest, EventListenerManagerTestAddDeathRecipient_001, TestSize.Level0)
 {
-    auto mockCallbackAdd = new MockEventListener();
+    sptr<MockEventListener> mockCallbackAdd = new MockEventListener();
     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject);
     EXPECT_CALL(*mockCallbackAdd, AsObject())
-        .WillOnce(Return(obj))
         .WillRepeatedly(Return(obj));
 
     EXPECT_CALL(*obj, AddDeathRecipient(_))
@@ -101,17 +99,17 @@ HWTEST_F(EventListenerManagerTest, EventListenerManagerTestAddDeathRecipient_001
 
 HWTEST_F(EventListenerManagerTest, EventListenerManagerTestAddDeathRecipient_002, TestSize.Level0)
 {
-    auto mockCallbackAdd = new MockEventListener();
+    sptr<MockEventListener> mockCallbackAdd = new MockEventListener();
     sptr<MockRemoteObject> obj(new (std::nothrow) MockRemoteObject);
     EXPECT_CALL(*mockCallbackAdd, AsObject())
-        .WillOnce(Return(obj))
         .WillRepeatedly(Return(obj));
 
     EXPECT_CALL(*obj, AddDeathRecipient(_))
-        .WillOnce(Return(true));
+        .WillRepeatedly(Return(true));
 
     AuthEventListenerManager& authEventListenerManager = AuthEventListenerManager::GetInstance();
     EXPECT_EQ(authEventListenerManager.AddDeathRecipient(&authEventListenerManager, mockCallbackAdd), SUCCESS);
+    EXPECT_EQ(authEventListenerManager.AddDeathRecipient(&authEventListenerManager, mockCallbackAdd), SUCCESS);
 }
 } // namespace UserAuth
 } // namespace UserIam
diff --git a/test/unittest/services/src/risk_event_manager_test.cpp b/test/unittest/services/src/risk_event_manager_test.cpp
index a060a5233eded29c020a437fef00afcdeeca0d6e..f6d8e663516dbb52f415faa146863d4e48b290c8 100644
--- a/test/unittest/services/src/risk_event_manager_test.cpp
+++ b/test/unittest/services/src/risk_event_manager_test.cpp
@@ -19,6 +19,7 @@
 
 #include "iam_logger.h"
 #include "securec.h"
+#include "mock_iuser_auth_interface.h"
 
 #define LOG_TAG "USER_AUTH_SA"
 
@@ -54,6 +55,8 @@ HWTEST_F(RiskEventManagerTest, SetRiskEventPropertyForAuthTypeTest, TestSize.Lev
         AuthType::FACE, RiskEventManager::EventType::SCREENLOCK_STRONG_AUTH));
     EXPECT_NO_THROW(RiskEventManager::GetInstance().SetRiskEventPropertyForAuthType(mainUserId,
         AuthType::PIN, RiskEventManager::EventType::SCREENLOCK_STRONG_AUTH));
+    EXPECT_NO_THROW(RiskEventManager::GetInstance().SetRiskEventPropertyForAuthType(mainUserId,
+        AuthType::PIN, RiskEventManager::EventType::UNKNOWN));
 }
 
 HWTEST_F(RiskEventManagerTest, GetAttributesTest, TestSize.Level0)
@@ -84,6 +87,34 @@ HWTEST_F(RiskEventManagerTest, GetTemplateIdListTest, TestSize.Level0)
         templateIds));
 }
 
+HWTEST_F(RiskEventManagerTest, GetTemplateIdListTestFail, TestSize.Level0)
+{
+    int32_t mainUserId = 100;
+    AuthType authType = PIN;
+    std::vector<uint64_t> templateIds;
+    auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
+
+    {
+        EXPECT_CALL(*mock, GetCredential(_, _, _)).WillRepeatedly(Return(NOT_ENROLLED));
+        EXPECT_NO_THROW(RiskEventManager::GetInstance().GetTemplateIdList(mainUserId, authType, templateIds));
+    }
+
+    {
+        EXPECT_CALL(*mock, GetCredential(_, _, _)).WillRepeatedly(Return(1));
+        EXPECT_NO_THROW(RiskEventManager::GetInstance().GetTemplateIdList(mainUserId, authType, templateIds));
+    }
+}
+
+HWTEST_F(RiskEventManagerTest, SetAttributesTestFail, TestSize.Level0)
+{
+    int32_t mainUserId = 100;
+    Attributes attributes;
+    auto mock = MockIUserAuthInterface::Holder::GetInstance().Get();
+    EXPECT_CALL(*mock, GetCredential(_, _, _)).WillRepeatedly(Return(1));
+    EXPECT_NO_THROW(RiskEventManager::GetInstance().SetAttributes(mainUserId, AuthType::FACE,
+        RiskEventManager::EventType::SCREENLOCK_STRONG_AUTH, attributes));
+}
+
 HWTEST_F(RiskEventManagerTest, GetStrongAuthExtraInfoTest, TestSize.Level0)
 {
     std::vector<uint8_t> extraInfo;
diff --git a/test/unittest/services/src/schedule_node_test.cpp b/test/unittest/services/src/schedule_node_test.cpp
index 4359fc9de06fa0a2426c7f6f71807473cd900dbc..c542ef9a7c10154a8de0738172613b67df08899a 100644
--- a/test/unittest/services/src/schedule_node_test.cpp
+++ b/test/unittest/services/src/schedule_node_test.cpp
@@ -52,6 +52,10 @@ HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderWithNullptr, TestSize.Level1)
 {
     auto builder = ScheduleNode::Builder::New(nullptr, nullptr);
     EXPECT_EQ(builder, nullptr);
+    
+    auto faceAllInOne = MockResourceNode::CreateWithExecuteIndex(1, FACE, ALL_IN_ONE);
+    builder = ScheduleNode::Builder::New(faceAllInOne, nullptr);
+    EXPECT_EQ(builder, nullptr);
 }
 
 HWTEST_F(ScheduleNodeTest, ScheduleNodeBuilderOneCollectorFailed, TestSize.Level1)
@@ -613,6 +617,44 @@ HWTEST_F(ScheduleNodeTest, ScheduleNodeTestSendMessage, TestSize.Level1)
     EXPECT_NE(scheduleNode, nullptr);
     EXPECT_TRUE(scheduleNode->SendMessage(testDstRole, testMsg));
 }
+
+HWTEST_F(ScheduleNodeTest, ScheduleNodeRemotePinSuccess, TestSize.Level1)
+{
+    MockExecutorCallback collector;
+    MockExecutorCallback verifier;
+    EXPECT_CALL(collector, OnBeginExecute(_, _, _)).WillRepeatedly(Return(0));
+    EXPECT_CALL(verifier, OnBeginExecute(_, _, _)).WillRepeatedly(Return(0));
+
+    auto callback = MockScheduleNodeCallback::Create();
+    EXPECT_CALL(*callback, OnScheduleStarted()).Times(1);
+
+    auto handler = ThreadHandler::GetSingleThreadInstance();
+    ASSERT_NE(handler, nullptr);
+    {
+        constexpr uint32_t EXECUTOR_INDEX = 0xAAAAAAA;
+        constexpr uint32_t EXECUTOR_MATCHER = 0xDEEDBEEF;
+        constexpr uint32_t SCHEDULE_ID = 0xBEEFABCD;
+        auto pinCollector = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX, FACE, COLLECTOR, collector);
+        auto pinVerifier = MockResourceNode::CreateWithExecuteIndex(EXECUTOR_INDEX + 1, FACE, VERIFIER, verifier);
+        
+        auto builder = ScheduleNode::Builder::New(pinCollector, pinVerifier);
+        ASSERT_NE(builder, nullptr);
+        builder->SetExecutorMatcher(EXECUTOR_MATCHER);
+        builder->SetThreadHandler(handler);
+        builder->SetScheduleId(SCHEDULE_ID);
+        builder->SetScheduleMode(IDENTIFY);
+        builder->SetScheduleCallback(callback);
+
+        auto scheduleNode = builder->Build();
+        ASSERT_NE(scheduleNode, nullptr);
+
+        EXPECT_TRUE(scheduleNode->StartSchedule());
+        handler->EnsureTask([]() {});
+        EXPECT_EQ(scheduleNode->GetCurrentScheduleState(), ScheduleNode::S_AUTH_PROCESSING);
+    }
+    handler->EnsureTask([]() {});
+}
+
 } // namespace UserAuth
 } // namespace UserIam
 } // namespace OHOS