diff --git a/services/ans/test/unittest/BUILD.gn b/services/ans/test/unittest/BUILD.gn
index 1b55a7c8d5c984895bc19ece0496a8bdc0777bd1..e1a6da7a5dd65f6441f461eccf65ebd4265967b6 100644
--- a/services/ans/test/unittest/BUILD.gn
+++ b/services/ans/test/unittest/BUILD.gn
@@ -38,11 +38,11 @@ ohos_unittest("ans_unit_test") {
     "${services_path}/ans/src/notification_preferences_database.cpp",
     "${services_path}/ans/src/notification_preferences_info.cpp",
     "${services_path}/ans/src/notification_slot_filter.cpp",
-    "${services_path}/ans/src/notification_subscriber_manager.cpp",
-    "${services_path}/ans/src/permission_filter.cpp",
     "${services_path}/ans/src/reminder_data_manager.cpp",
     "${services_path}/ans/src/reminder_event_manager.cpp",
     "${services_path}/ans/src/reminder_timer_info.cpp",
+    "${services_path}/ans/src/notification_subscriber_manager.cpp",
+    "${services_path}/ans/src/permission_filter.cpp",
     "${services_path}/ans/src/system_event_observer.cpp",
     "advanced_notification_service_ability_test.cpp",
     "advanced_notification_service_test.cpp",
@@ -60,6 +60,98 @@ ohos_unittest("ans_unit_test") {
     "notification_slot_filter_test.cpp",
     "notification_subscriber_manager_test.cpp",
     "permission_filter_test.cpp",
+  ]
+
+  configs = [ "//commonlibrary/c_utils/base:utils_config" ]
+
+  deps = [
+    "${core_path}:ans_core",
+    "${frameworks_module_ans_path}:ans_innerkits",
+    "//foundation/arkui/ace_engine/interfaces/inner_api/ui_service_manager:ui_service_mgr",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  if (distributed_notification_supported) {
+    defines += [ "DISTRIBUTED_NOTIFICATION_SUPPORTED" ]
+    deps += [ "${services_path}/distributed:libans_distributed" ]
+    include_dirs += [ "${services_path}/distributed/include" ]
+  }
+
+  external_deps = [
+    "ability_base:want",
+    "ability_base:zuri",
+    "ability_runtime:abilitykit_native",
+    "ability_runtime:app_manager",
+    "ability_runtime:wantagent_innerkits",
+    "access_token:libaccesstoken_sdk",
+    "bundle_framework:appexecfwk_base",
+    "bundle_framework:appexecfwk_core",
+    "c_utils:utils",
+    "common_event_service:cesfwk_innerkits",
+    "eventhandler:libeventhandler",
+    "hitrace_native:hitrace_meter",
+    "hitrace_native:libhitracechain",
+    "hiviewdfx_hilog_native:libhilog",
+    "ipc:ipc_core",
+    "kv_store:distributeddata_inner",
+    "multimedia_image_framework:image_native",
+    "multimedia_player_framework:media_client",
+    "os_account:os_account_innerkits",
+    "relational_store:native_rdb",
+    "safwk:system_ability_fwk",
+    "samgr:samgr_proxy",
+    "time_service:time_client",
+  ]
+
+  if (device_usage) {
+    external_deps += [ "device_usage_statistics:usagestatsinner" ]
+    defines += [ "DEVICE_USAGE_STATISTICS_ENABLE" ]
+  }
+
+  cflags = []
+  if (hisysevent_usage) {
+    external_deps += [ "hisysevent_native:libhisysevent" ]
+    cflags += [ "-DHAS_HISYSEVENT_PART" ]
+  }
+
+  subsystem_name = "${subsystem_name}"
+  part_name = "${component_name}"
+}
+
+ohos_unittest("reminder_unit_test") {
+  module_out_path = module_output_path
+  include_dirs = [
+    ".",
+    "include",
+    "//commonlibrary/c_utils/base/include",
+    "//utils/system/safwk/native/include",
+    "/${services_path}/ans/include",
+    "${services_path}/ans/test/unittest/mock/include",
+  ]
+
+  defines = []
+
+  sources = [
+    "${services_path}/ans/src/advanced_notification_service.cpp",
+    "${services_path}/ans/src/advanced_notification_service_ability.cpp",
+    "${services_path}/ans/src/event_report.cpp",
+    "${services_path}/ans/src/notification_preferences.cpp",
+    "${services_path}/ans/src/notification_preferences_database.cpp",
+    "${services_path}/ans/src/notification_preferences_info.cpp",
+    "${services_path}/ans/src/notification_slot_filter.cpp",
+    "${services_path}/ans/src/notification_subscriber_manager.cpp",
+    "${services_path}/ans/src/permission_filter.cpp",
+    "${services_path}/ans/src/reminder_data_manager.cpp",
+    "${services_path}/ans/src/reminder_event_manager.cpp",
+    "${services_path}/ans/src/reminder_timer_info.cpp",
+    "${services_path}/ans/src/system_event_observer.cpp",
+    "mock/blob.cpp",
+    "mock/distributed_kv_data_manager.cpp",
+    "mock/mock_access_token_helper.cpp",
+    "mock/mock_bundle_manager_helper.cpp",
+    "mock/mock_event_handler.cpp",
+    "mock/mock_ipc.cpp",
+    "mock/mock_single_kv_store.cpp",
     "reminder_data_manager_test.cpp",
   ]
 
@@ -98,6 +190,7 @@ ohos_unittest("ans_unit_test") {
     "multimedia_image_framework:image_native",
     "multimedia_player_framework:media_client",
     "os_account:os_account_innerkits",
+    "relational_store:native_rdb",
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
     "time_service:time_service",
@@ -122,5 +215,8 @@ group("unittest") {
   testonly = true
   deps = []
 
-  deps += [ ":ans_unit_test" ]
+  deps += [
+    ":ans_unit_test",
+    ":reminder_unit_test"
+  ]
 }
diff --git a/services/ans/test/unittest/reminder_data_manager_test.cpp b/services/ans/test/unittest/reminder_data_manager_test.cpp
index 1ad03b0422258ac7524bbeccdeeb54aeeba6604b..65c45bc2ed8033723a946f7cebf9d43a79f21b69 100644
--- a/services/ans/test/unittest/reminder_data_manager_test.cpp
+++ b/services/ans/test/unittest/reminder_data_manager_test.cpp
@@ -18,13 +18,21 @@
 
 #define private public
 #define protected public
+#include "common_event_data.h"
+#include "common_event_manager.h"
+#include "common_event_support.h"
+#include "matching_skills.h"
 #include "reminder_data_manager.h"
+#include "reminder_event_manager.h"
+#include "reminder_request_timer.h"
 #undef private
 #undef protected
 
 using namespace testing::ext;
+using namespace OHOS::EventFwk;
 namespace OHOS {
 namespace Notification {
+static auto manager = std::make_shared<ReminderDataManager>();
 class ReminderDataManagerTest : public testing::Test {
 public:
     static void SetUpTestCase() {};
@@ -34,154 +42,425 @@ public:
 };
 
 /**
- * @tc.number    : ReminderDataManagerTest_00200
- * @tc.name      : CheckReminderLimitExceededLocked
- * @tc.desc      : Test CheckReminderLimitExceededLocked function when the  bundleOption is nullptr,return is false
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_001
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_00200, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_001, Level1)
 {
-    sptr<NotificationBundleOption> bundleOption = nullptr;
-    ReminderDataManager reminderDataManager;
-    bool result = reminderDataManager.CheckReminderLimitExceededLocked(bundleOption);
-    EXPECT_EQ(result, false);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    sptr<NotificationBundleOption> option = new NotificationBundleOption();
+    manager->PublishReminder(reminder, option);
+    manager->CancelReminder(-1, option);
+    manager->CancelAllReminders("", -1);
+    manager->CancelAllReminders(-1);
+    manager->IsMatched(reminder, "", -1);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_00300
- * @tc.name      : FindReminderRequestLocked
- * @tc.desc      : Test FindReminderRequestLocked function when the result is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_002
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_00300, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_002, Level1)
 {
-    int32_t reminderId = 1;
-    ReminderDataManager reminderDataManager;
-    sptr<ReminderRequest> result = reminderDataManager.FindReminderRequestLocked(reminderId);
-    EXPECT_EQ(result, nullptr);
+    sptr<NotificationBundleOption> option = new NotificationBundleOption();
+    std::vector<sptr<ReminderRequest>> vec;
+    manager->GetValidReminders(option, vec);
+    manager->CheckReminderLimitExceededLocked(option);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->CancelNotification(reminder);
+    reminder->SetReminderId(10);
+    manager->AddToShowedReminders(reminder);
+    manager->AddToShowedReminders(reminder);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_00400
- * @tc.name      : FindReminderRequestLocked
- * @tc.desc      : Test FindReminderRequestLocked function when the result is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_003
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_00400, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_003, Level1)
 {
-    int32_t reminderId = 1;
-    std::string pkgName = "PkgName";
-    ReminderDataManager reminderDataManager;
-    sptr<ReminderRequest> result = reminderDataManager.FindReminderRequestLocked(reminderId, pkgName);
-    EXPECT_EQ(result, nullptr);
+    manager->isReminderAgentReady_ = false;
+    manager->alertingReminderId_ = -1;
+    manager->OnUserSwitch(0);
+    manager->OnUserRemove(0);
+    manager->alertingReminderId_ = 1;
+    manager->OnUserSwitch(0);
+    manager->isReminderAgentReady_ = true;
+    manager->OnUserSwitch(0);
+    manager->alertingReminderId_ = -1;
+    manager->OnUserSwitch(0);
+    manager->OnUserRemove(0);
+    manager->OnServiceStart();
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_00500
- * @tc.name      : FindNotificationBundleOption
- * @tc.desc      : Test FindNotificationBundleOption function when the result is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_004
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_00500, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_004, Level1)
 {
-    int32_t reminderId = 1;
-    ReminderDataManager reminderDataManager;
-    sptr<NotificationBundleOption> result = reminderDataManager.FindNotificationBundleOption(reminderId);
-    EXPECT_EQ(result, nullptr);
+    sptr<NotificationBundleOption> option = new NotificationBundleOption();
+    manager->OnProcessDiedLocked(option);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->CreateTimerInfo(ReminderDataManager::TimerType::TRIGGER_TIMER, reminder);
+    manager->CreateTimerInfo(ReminderDataManager::TimerType::ALERTING_TIMER, reminder);
+    manager->FindReminderRequestLocked(0, "");
+    reminder->SetReminderId(10);
+    manager->reminderVector_.push_back(reminder);
+    manager->FindReminderRequestLocked(10, "");
+    option->SetBundleName("test");
+    manager->notificationBundleOptionMap_[10] = option;
+    manager->FindReminderRequestLocked(10, "");
+    manager->FindReminderRequestLocked(10, "test");
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_00700
- * @tc.name      : GetInstance
- * @tc.desc      : Test GetInstance function when the result is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_005
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_00700, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_005, Level1)
 {
-    ReminderDataManager reminderDataManager;
-    std::shared_ptr<ReminderDataManager> result = reminderDataManager.GetInstance();
-    EXPECT_EQ(result, nullptr);
+    EventFwk::Want want;
+    manager->CloseReminder(want, true);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    reminder->SetReminderId(1);
+    manager->activeReminderId_ = 1;
+    manager->activeReminder_ = reminder;
+    manager->CloseReminder(reminder, true);
+    reminder->SetReminderId(2);
+    manager->alertingReminderId_ = 2;
+    manager->CloseReminder(reminder, true);
+    reminder->SetReminderId(3);
+    manager->CloseReminder(reminder, true);
+    manager->CloseReminder(reminder, false);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_00900
- * @tc.name      : ShouldAlert
- * @tc.desc      : Test ShouldAlert function when the result is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_006
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_00900, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_006, Level1)
 {
-    sptr<ReminderRequest> reminder = nullptr;
-    ReminderDataManager reminderDataManager;
-    bool result = reminderDataManager.ShouldAlert(reminder);
-    EXPECT_EQ(result, false);
+    manager->RefreshRemindersDueToSysTimeChange(0);
+    manager->RefreshRemindersDueToSysTimeChange(1);
+    manager->activeReminderId_ = 1;
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->activeReminder_ = reminder;
+    manager->RefreshRemindersDueToSysTimeChange(1);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_01200
- * @tc.name      : GetRecentReminderLocked
- * @tc.desc      : Test GetRecentReminderLocked function when the result is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_007
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_01200, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_007, Level1)
 {
-    ReminderDataManager reminderDataManager;
-    sptr<ReminderRequest> result = reminderDataManager.GetRecentReminderLocked();
-    EXPECT_EQ(result, nullptr);
+    EventFwk::Want want;
+    want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
+    manager->ShowActiveReminder(want);
+    manager->CloseReminder(want, true);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    reminder->SetReminderId(10);
+    manager->reminderVector_.push_back(reminder);
+    manager->ShowActiveReminder(want);
+    manager->activeReminderId_ = 10;
+    manager->activeReminder_ = reminder;
+    manager->ShowActiveReminder(want);
+    manager->CloseReminder(want, true);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_01400
- * @tc.name      : IsAllowedNotify
- * @tc.desc      : Test IsAllowedNotify function when the  reminder is nullptr ,the result is false
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_008
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_01400, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_008, Level1)
 {
-    sptr<ReminderRequest> reminder = nullptr;
-    ReminderDataManager reminderDataManager;
-    bool result = reminderDataManager.IsAllowedNotify(reminder);
-    EXPECT_EQ(result, false);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->TerminateAlerting(0, reminder);
+    manager->TerminateAlerting(nullptr, "");
+    manager->TerminateAlerting(reminder, "");
+    reminder->state_ = 2;
+    manager->TerminateAlerting(reminder, "");
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_01500
- * @tc.name      : IsReminderAgentReady
- * @tc.desc      : Test IsReminderAgentReady function
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_009
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_01500, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_009, Level1)
 {
-    ReminderDataManager reminderDataManager;
-    bool result = reminderDataManager.IsReminderAgentReady();
-    EXPECT_EQ(result, true);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    sptr<NotificationBundleOption> option = new NotificationBundleOption();
+    manager->UpdateAndSaveReminderLocked(reminder, option);
+    AdvancedNotificationService service;
+    manager->SetService(&service);
+    manager->ShouldAlert(nullptr);
+    manager->currentUserId_ = 0;
+    option->SetUid(1);
+    manager->ShouldAlert(reminder);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_01700
- * @tc.name      : GetSoundUri
- * @tc.desc      : Test GetSoundUri function when the  reminder is nullptr
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_010
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_01700, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_010, Level1)
 {
-    sptr<ReminderRequest> reminder = nullptr;
-    ReminderDataManager reminderDataManager;
-    std::string result = reminderDataManager.GetSoundUri(reminder);
-    EXPECT_EQ(result, "//system/etc/Light.ogg");
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->HandleSysTimeChange(reminder);
+    manager->SetActiveReminder(nullptr);
+    manager->SetActiveReminder(reminder);
+    manager->SetAlertingReminder(nullptr);
+    manager->SetAlertingReminder(reminder);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 
 /**
- * @tc.number    : ReminderDataManagerTest_01100
- * @tc.name      : Dump
- * @tc.desc      : Test Dump function
- * @tc.require   : issueI5S4VP
+ * @tc.name: ReminderDataManagerTest_011
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
  */
-HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_01100, Level1)
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_011, Level1)
 {
-    ReminderDataManager reminderDataManager;
-    std::string result = reminderDataManager.Dump();
-    EXPECT_EQ(result.size(), 68);
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    reminder->SetReminderId(0);
+    sptr<NotificationBundleOption> option = new NotificationBundleOption();
+    manager->notificationBundleOptionMap_[10] = option;
+    manager->ShowReminder(reminder, true, true, true, true);
+    reminder->SetReminderId(10);
+    manager->ShowReminder(reminder, true, true, true, true);
+    manager->ShowReminder(reminder, true, true, true, true);
+    manager->alertingReminderId_ = 1;
+    manager->ShowReminder(reminder, true, true, true, true);
+    manager->alertingReminderId_ = -1;
+    manager->ShowReminder(reminder, true, true, true, true);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderDataManagerTest_012
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_012, Level1)
+{
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->activeReminderId_ = 10;
+    manager->activeReminder_ = reminder;
+    reminder->SetReminderId(10);
+    manager->activeReminderId_ = 1;
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderDataManagerTest_013
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_013, Level1)
+{
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    manager->activeReminderId_ = 10;
+    manager->activeReminder_ = reminder;
+    reminder->SetReminderId(10);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderDataManagerTest_014
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_014, Level1)
+{
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    reminder->SetReminderId(0);
+    manager->StartRecentReminder();
+    manager->StopAlertingReminder(nullptr);
+    manager->alertingReminderId_ = -1;
+    manager->StopAlertingReminder(reminder);
+    manager->alertingReminderId_ = 1;
+    manager->StopAlertingReminder(reminder);
+    reminder->SetReminderId(1);
+    manager->StopAlertingReminder(reminder);
+    manager->Dump();
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderDataManagerTest_015
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_015, Level1)
+{
+    sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
+    std::vector<sptr<ReminderRequest>> vec;
+    vec.push_back(reminder);
+    manager->HandleImmediatelyShow(vec, true);
+    manager->HandleRefreshReminder(0, reminder);
+    manager->HandleSameNotificationIdShowing(reminder);
+    manager->Init(true);
+    manager->InitUserId();
+    manager->GetImmediatelyShowRemindersLocked(vec);
+    manager->IsAllowedNotify(reminder);
+    manager->IsAllowedNotify(nullptr);
+    manager->IsReminderAgentReady();
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderEventManagerTest_001
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_001, Level1)
+{
+    MatchingSkills matchingSkills;
+    matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
+    matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
+    matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
+    matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
+    matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
+    CommonEventSubscribeInfo subscriberInfo(matchingSkills);
+    auto subscriber = std::make_shared<ReminderEventManager::ReminderEventSubscriber>(subscriberInfo, manager);
+    EventFwk::CommonEventData data;
+    Want want;
+    want.SetAction(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    want.SetAction(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
+    data.SetWant(want);
+    subscriber->OnReceiveEvent(data);
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderEventManagerTest_002
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_002, Level1)
+{
+    auto statusChangeListener
+        = std::make_shared<ReminderEventManager::SystemAbilityStatusChangeListener>(manager);
+    statusChangeListener->OnAddSystemAbility(0, "");
+    statusChangeListener->OnRemoveSystemAbility(0, "");
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
+}
+
+/**
+ * @tc.name: ReminderEventManagerTest_003
+ * @tc.desc: Reminder data manager test
+ * @tc.type: FUNC
+ * @tc.require: issueI5YTF3
+ */
+HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_003, Level1)
+{
+    auto timeInfo = std::make_shared<ReminderTimerInfo>();
+    timeInfo->SetType(0);
+    timeInfo->SetRepeat(false);
+    timeInfo->SetInterval(0);
+    timeInfo->SetWantAgent(nullptr);
+    timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALARM_ALERT;
+    timeInfo->OnTrigger();
+    timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT;
+    timeInfo->OnTrigger();
+    system("rm -rf /data/service/el1/public/notification/");
+    EXPECT_TRUE(manager != nullptr);
 }
 }  // namespace Notification
 }  // namespace OHOS