1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <map>
17 #include <functional>
18 #include <gtest/gtest.h>
19 
20 #define private public
21 #define protected public
22 #include "common_event_data.h"
23 #include "common_event_manager.h"
24 #include "common_event_support.h"
25 #include "matching_skills.h"
26 #include "reminder_data_manager.h"
27 #include "reminder_event_manager.h"
28 #include "reminder_request_timer.h"
29 #include "reminder_request_alarm.h"
30 #include "reminder_request.h"
31 #include "reminder_request_calendar.h"
32 #include "ability_manager_client.h"
33 #include "mock_ipc_skeleton.h"
34 #undef private
35 #undef protected
36 
37 using namespace testing::ext;
38 using namespace OHOS::EventFwk;
39 namespace OHOS {
40 namespace Notification {
41 class ReminderDataManagerTest : public testing::Test {
42 public:
SetUpTestCase()43     static void SetUpTestCase()
44     {
45         ReminderDataManager::InitInstance(nullptr);
46         manager = ReminderDataManager::GetInstance();
47         manager->Init(false);
48     }
TearDownTestCase()49     static void TearDownTestCase()
50     {
51         manager = nullptr;
52     }
SetUp()53     void SetUp() {};
TearDown()54     void TearDown() {};
55 
56 public:
57     static std::shared_ptr<ReminderDataManager> manager;
58 };
59 
60 std::shared_ptr<ReminderDataManager> ReminderDataManagerTest::manager = nullptr;
61 
62 /**
63  * @tc.name: ReminderDataManagerTest_001
64  * @tc.desc: Reminder data manager test
65  * @tc.type: FUNC
66  * @tc.require: issueI5YTF3
67  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_001,Level1)68 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_001, Level1)
69 {
70     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
71     sptr<NotificationBundleOption> option = new NotificationBundleOption();
72     manager->PublishReminder(reminder, option);
73     manager->CancelReminder(-1, option);
74     manager->CancelAllReminders("", -1, -1);
75     manager->CancelAllReminders(-1);
76     manager->IsMatched(reminder, "", -1, -1);
77     system("rm -rf /data/service/el1/public/notification/");
78     EXPECT_TRUE(manager != nullptr);
79 }
80 
81 /**
82  * @tc.name: ReminderDataManagerTest_002
83  * @tc.desc: Reminder data manager test
84  * @tc.type: FUNC
85  * @tc.require: issueI5YTF3
86  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_002,Level1)87 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_002, Level1)
88 {
89     sptr<NotificationBundleOption> option = new NotificationBundleOption();
90     std::vector<sptr<ReminderRequest>> vec;
91     manager->GetValidReminders(option, vec);
92     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
93     manager->CheckReminderLimitExceededLocked(option, reminder);
94     manager->CancelNotification(reminder);
95     reminder->SetReminderId(10);
96     manager->AddToShowedReminders(reminder);
97     manager->AddToShowedReminders(reminder);
98     system("rm -rf /data/service/el1/public/notification/");
99     EXPECT_TRUE(manager != nullptr);
100 }
101 
102 /**
103  * @tc.name: ReminderDataManagerTest_003
104  * @tc.desc: Reminder data manager test
105  * @tc.type: FUNC
106  * @tc.require: issueI5YTF3
107  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_003,Level1)108 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_003, Level1)
109 {
110     manager->isReminderAgentReady_ = false;
111     manager->alertingReminderId_ = -1;
112     manager->OnUserSwitch(0);
113     manager->OnUserRemove(0);
114     manager->alertingReminderId_ = 1;
115     manager->OnUserSwitch(0);
116     manager->isReminderAgentReady_ = true;
117     manager->OnUserSwitch(0);
118     manager->alertingReminderId_ = -1;
119     manager->OnUserSwitch(0);
120     manager->OnUserRemove(0);
121     manager->OnBundleMgrServiceStart();
122     manager->OnAbilityMgrServiceStart();
123     system("rm -rf /data/service/el1/public/notification/");
124     EXPECT_TRUE(manager != nullptr);
125 }
126 
127 /**
128  * @tc.name: ReminderDataManagerTest_004
129  * @tc.desc: Reminder data manager test
130  * @tc.type: FUNC
131  * @tc.require: issueI5YTF3
132  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_004,Level1)133 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_004, Level1)
134 {
135     sptr<NotificationBundleOption> option = new NotificationBundleOption();
136     manager->OnProcessDiedLocked(option);
137     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
138     manager->CreateTimerInfo(ReminderDataManager::TimerType::TRIGGER_TIMER, reminder);
139     manager->CreateTimerInfo(ReminderDataManager::TimerType::ALERTING_TIMER, reminder);
140     manager->FindReminderRequestLocked(0, "");
141     reminder->SetReminderId(10);
142     manager->reminderVector_.push_back(reminder);
143     manager->FindReminderRequestLocked(10, "");
144     option->SetBundleName("test");
145     manager->FindReminderRequestLocked(10, "");
146     manager->FindReminderRequestLocked(10, "test");
147     system("rm -rf /data/service/el1/public/notification/");
148     EXPECT_TRUE(manager != nullptr);
149 }
150 
151 /**
152  * @tc.name: ReminderDataManagerTest_005
153  * @tc.desc: Reminder data manager test
154  * @tc.type: FUNC
155  * @tc.require: issueI5YTF3
156  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_005,Level1)157 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_005, Level1)
158 {
159     EventFwk::Want want;
160     manager->CloseReminder(want, true);
161     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
162     reminder->SetReminderId(1);
163     manager->activeReminderId_ = 1;
164     manager->activeReminder_ = reminder;
165     manager->CloseReminder(reminder, true);
166     reminder->SetReminderId(2);
167     manager->alertingReminderId_ = 2;
168     manager->CloseReminder(reminder, true);
169     reminder->SetReminderId(3);
170     manager->CloseReminder(reminder, true);
171     manager->CloseReminder(reminder, false);
172     reminder->SetReminderId(4);
173     reminder->SetGroupId("");
174     manager->CloseReminder(reminder, true);
175     system("rm -rf /data/service/el1/public/notification/");
176     EXPECT_TRUE(manager != nullptr);
177 }
178 
179 /**
180  * @tc.name: ReminderDataManagerTest_006
181  * @tc.desc: Reminder data manager test
182  * @tc.type: FUNC
183  * @tc.require: issueI5YTF3
184  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_006,Level1)185 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_006, Level1)
186 {
187     manager->RefreshRemindersDueToSysTimeChange(0);
188     manager->RefreshRemindersDueToSysTimeChange(1);
189     manager->activeReminderId_ = 1;
190     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
191     manager->activeReminder_ = reminder;
192     manager->RefreshRemindersDueToSysTimeChange(1);
193     system("rm -rf /data/service/el1/public/notification/");
194     EXPECT_TRUE(manager != nullptr);
195 }
196 
197 /**
198  * @tc.name: ReminderDataManagerTest_007
199  * @tc.desc: Reminder data manager test
200  * @tc.type: FUNC
201  * @tc.require: issueI5YTF3
202  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_007,Level1)203 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_007, Level1)
204 {
205     EventFwk::Want want;
206     want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
207     manager->ShowActiveReminder(want);
208     manager->CloseReminder(want, true);
209     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
210     reminder->SetReminderId(10);
211     manager->reminderVector_.push_back(reminder);
212     manager->ShowActiveReminder(want);
213     manager->activeReminderId_ = 10;
214     manager->activeReminder_ = reminder;
215     manager->ShowActiveReminder(want);
216     manager->CloseReminder(want, true);
217     system("rm -rf /data/service/el1/public/notification/");
218     EXPECT_TRUE(manager != nullptr);
219 }
220 
221 /**
222  * @tc.name: ReminderDataManagerTest_008
223  * @tc.desc: Reminder data manager test
224  * @tc.type: FUNC
225  * @tc.require: issueI5YTF3
226  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_008,Level1)227 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_008, Level1)
228 {
229     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
230     manager->TerminateAlerting(0, reminder);
231     manager->TerminateAlerting(nullptr, "");
232     manager->TerminateAlerting(reminder, "");
233     reminder->state_ = 2;
234     manager->TerminateAlerting(reminder, "");
235     system("rm -rf /data/service/el1/public/notification/");
236     EXPECT_TRUE(manager != nullptr);
237 }
238 
239 /**
240  * @tc.name: ReminderDataManagerTest_009
241  * @tc.desc: Reminder data manager test
242  * @tc.type: FUNC
243  * @tc.require: issueI5YTF3
244  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_009,Level1)245 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_009, Level1)
246 {
247     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
248     sptr<NotificationBundleOption> option = new NotificationBundleOption();
249     manager->UpdateAndSaveReminderLocked(reminder, option);
250     sptr<AdvancedNotificationService> service(new AdvancedNotificationService);
251     manager->SetService(service);
252     manager->ShouldAlert(nullptr);
253     manager->currentUserId_ = 0;
254     option->SetUid(1);
255     manager->ShouldAlert(reminder);
256     system("rm -rf /data/service/el1/public/notification/");
257     EXPECT_TRUE(manager != nullptr);
258 }
259 
260 /**
261  * @tc.name: ReminderDataManagerTest_010
262  * @tc.desc: Reminder data manager test
263  * @tc.type: FUNC
264  * @tc.require: issueI5YTF3
265  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_010,Level1)266 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_010, Level1)
267 {
268     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
269     manager->HandleSysTimeChange(reminder);
270     manager->SetActiveReminder(nullptr);
271     manager->SetActiveReminder(reminder);
272     manager->SetAlertingReminder(nullptr);
273     manager->SetAlertingReminder(reminder);
274     system("rm -rf /data/service/el1/public/notification/");
275     EXPECT_TRUE(manager != nullptr);
276 }
277 
278 /**
279  * @tc.name: ReminderDataManagerTest_011
280  * @tc.desc: Reminder data manager test
281  * @tc.type: FUNC
282  * @tc.require: issueI5YTF3
283  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_011,Level1)284 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_011, Level1)
285 {
286     sptr<ReminderRequest> reminder(new ReminderRequestTimer(10));
287     reminder->SetReminderId(0);
288     sptr<NotificationBundleOption> option(new NotificationBundleOption());
289     manager->ShowReminder(reminder, true, true, true, true);
290     reminder->SetNotificationBundleOption(option);
291     reminder->SetReminderId(10);
292     manager->ShowReminder(reminder, true, true, true, true);
293     manager->ShowReminder(reminder, true, true, true, true);
294     manager->alertingReminderId_ = 1;
295     manager->ShowReminder(reminder, true, true, true, true);
296     manager->alertingReminderId_ = -1;
297     manager->ShowReminder(reminder, true, true, true, true);
298     system("rm -rf /data/service/el1/public/notification/");
299     EXPECT_TRUE(manager != nullptr);
300 }
301 
302 /**
303  * @tc.name: ReminderDataManagerTest_012
304  * @tc.desc: Reminder data manager test
305  * @tc.type: FUNC
306  * @tc.require: issueI5YTF3
307  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_012,Level1)308 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_012, Level1)
309 {
310     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
311     manager->activeReminderId_ = 10;
312     manager->activeReminder_ = reminder;
313     reminder->SetReminderId(10);
314     manager->activeReminderId_ = 1;
315     system("rm -rf /data/service/el1/public/notification/");
316     EXPECT_TRUE(manager != nullptr);
317 }
318 
319 /**
320  * @tc.name: ReminderDataManagerTest_013
321  * @tc.desc: Reminder data manager test
322  * @tc.type: FUNC
323  * @tc.require: issueI5YTF3
324  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_013,Level1)325 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_013, Level1)
326 {
327     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
328     manager->activeReminderId_ = 10;
329     manager->activeReminder_ = reminder;
330     reminder->SetReminderId(10);
331     system("rm -rf /data/service/el1/public/notification/");
332     EXPECT_TRUE(manager != nullptr);
333 }
334 
335 /**
336  * @tc.name: ReminderDataManagerTest_014
337  * @tc.desc: Reminder data manager test
338  * @tc.type: FUNC
339  * @tc.require: issueI5YTF3
340  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_014,Level1)341 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_014, Level1)
342 {
343     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
344     reminder->SetReminderId(0);
345     manager->StartRecentReminder();
346     manager->StopAlertingReminder(nullptr);
347     manager->alertingReminderId_ = -1;
348     manager->StopAlertingReminder(reminder);
349     manager->alertingReminderId_ = 1;
350     manager->StopAlertingReminder(reminder);
351     reminder->SetReminderId(1);
352     manager->StopAlertingReminder(reminder);
353     manager->Dump();
354     system("rm -rf /data/service/el1/public/notification/");
355     EXPECT_TRUE(manager != nullptr);
356 }
357 
358 /**
359  * @tc.name: ReminderDataManagerTest_015
360  * @tc.desc: Reminder data manager test
361  * @tc.type: FUNC
362  * @tc.require: issueI5YTF3
363  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_015,Level1)364 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_015, Level1)
365 {
366     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
367     std::vector<sptr<ReminderRequest>> vec;
368     vec.push_back(reminder);
369     manager->HandleImmediatelyShow(vec, true);
370     manager->HandleRefreshReminder(0, reminder);
371     manager->HandleSameNotificationIdShowing(reminder);
372     manager->Init(true);
373     manager->InitUserId();
374     manager->GetImmediatelyShowRemindersLocked(vec);
375     manager->IsAllowedNotify(reminder);
376     manager->IsAllowedNotify(nullptr);
377     manager->IsReminderAgentReady();
378     system("rm -rf /data/service/el1/public/notification/");
379     EXPECT_TRUE(manager != nullptr);
380 }
381 
382 /**
383  * @tc.name: ReminderDataManagerTest_016
384  * @tc.desc: Reminder data manager test
385  * @tc.type: FUNC
386  * @tc.require: issuesI8CAQB
387  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_016,Level1)388 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_016, Level1)
389 {
390     // not SystemApp
391     std::vector<uint8_t> daysOfWeek;
392     sptr<ReminderRequest> reminder = new ReminderRequestAlarm(0, 1, daysOfWeek);
393     std::shared_ptr<ReminderRequest::ButtonWantAgent> buttonWantAgent =
394         std::make_shared<ReminderRequest::ButtonWantAgent>();
395     std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> buttonDataShareUpdate =
396         std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
397     reminder->SetSystemApp(false);
398     reminder->SetActionButton("不再提醒", ReminderRequest::ActionButtonType::CLOSE,
399         "", buttonWantAgent, buttonDataShareUpdate);
400     manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::CLOSE);
401 
402     // INVALID ActionButtonType
403     reminder->SetSystemApp(true);
404     reminder->SetActionButton("无效的", ReminderRequest::ActionButtonType::INVALID,
405         "", buttonWantAgent, buttonDataShareUpdate);
406     manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::INVALID);
407 
408     // actionButtonType does not exist
409     std::map<ReminderRequest::ActionButtonType, ReminderRequest::ActionButtonInfo> actionButtonMap;
410     manager->CheckUpdateConditions(reminder, ReminderRequest::ActionButtonType::CLOSE, actionButtonMap);
411 
412     // null ButtonDataShareUpdate
413     reminder->SetActionButton("稍后提醒", ReminderRequest::ActionButtonType::SNOOZE, "", buttonWantAgent);
414     manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::SNOOZE);
415 
416     // not have uri
417     manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::CLOSE);
418 
419     // update datashare
420     sptr<ReminderRequest> reminder1 = new ReminderRequestAlarm(2, 3, daysOfWeek);
421     std::shared_ptr<ReminderRequest::ButtonWantAgent> buttonWantAgent1 =
422         std::make_shared<ReminderRequest::ButtonWantAgent>();
423     std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> buttonDataShareUpdate1 =
424         std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
425     reminder1->SetSystemApp(true);
426     reminder1->InitUserId(100);
427     buttonDataShareUpdate1->uri = "datashareTest://com.acts.dataShareTest";
428     buttonDataShareUpdate1->equalTo = "name<SEP:/>string<SEP:/>li<SEP;/>"
429         "id<SEP:/>double<SEP:/>3.0<SEP;/>status<SEP:/>bool<SEP:/>true";
430     buttonDataShareUpdate1->valuesBucket = "name<SEP:/>string<SEP:/>wang<SEP;/>"
431         "id<SEP:/>double<SEP:/>4.0<SEP;/>status<SEP:/>bool<SEP:/>true<SEP;/>actionId<SEP:/>null<SEP:/>null";
432     reminder1->SetActionButton("不再提醒", ReminderRequest::ActionButtonType::CLOSE, "",
433         buttonWantAgent1, buttonDataShareUpdate1);
434     manager->UpdateAppDatabase(reminder1, ReminderRequest::ActionButtonType::CLOSE);
435     EXPECT_TRUE(reminder1->actionButtonMap_.size() > 0);
436 }
437 
438 /**
439  * @tc.name: ReminderDataManagerTest_017
440  * @tc.desc: Reminder data manager test
441  * @tc.type: FUNC
442  * @tc.require: issueI8CDH3
443  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_017,Level1)444 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_017, Level1)
445 {
446     IPCSkeleton::SetCallingTokenID(1);
447     sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(10);
448     sptr<ReminderRequest> reminder2 = new ReminderRequestTimer(10);
449     sptr<ReminderRequest> reminder3 = new ReminderRequestTimer(10);
450     int32_t oldReminderId = 1;
451     reminder1->SetReminderId(1);
452     reminder2->SetReminderId(2);
453     reminder3->SetReminderId(3);
454     reminder1->SetGroupId("123");
455     reminder2->SetGroupId("123");
456     reminder3->SetGroupId("124");
457     sptr<NotificationBundleOption> option1 = new NotificationBundleOption();
458     sptr<NotificationBundleOption> option2 = new NotificationBundleOption();
459     sptr<NotificationBundleOption> option3 = new NotificationBundleOption();
460     option1->SetBundleName("test");
461     option2->SetBundleName("test");
462     manager->PublishReminder(reminder1, option1);
463     manager->PublishReminder(reminder2, option2);
464     manager->PublishReminder(reminder3, option3);
465     manager->CloseRemindersByGroupId(oldReminderId, "test", "123");
466     system("rm -rf /data/service/el1/public/notification/");
467     EXPECT_TRUE(reminder2->isExpired_);
468 }
469 
470 /**
471  * @tc.name: ReminderDataManagerTest_018
472  * @tc.desc: Reminder data manager test
473  * @tc.type: FUNC
474  * @tc.require: issueI8E7Z1
475  */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_018,Level1)476 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_018, Level1)
477 {
478     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
479     std::string ringUri = "123";
480     reminder->SetCustomRingUri(ringUri);
481     std::string getRingUri = manager->GetCustomRingUri(reminder);
482     ASSERT_EQ(ringUri, getRingUri);
483 }
484 
485 /**
486  * @tc.name: ReminderEventManagerTest_001
487  * @tc.desc: Reminder data manager test
488  * @tc.type: FUNC
489  * @tc.require: issueI5YTF3
490  */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_001,Level1)491 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_001, Level1)
492 {
493     MatchingSkills matchingSkills;
494     matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
495     matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
496     matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
497     matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
498     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
499     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
500     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
501     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
502     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
503     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
504     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
505     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
506     CommonEventSubscribeInfo subscriberInfo(matchingSkills);
507     auto subscriber = std::make_shared<ReminderEventManager::ReminderEventSubscriber>(subscriberInfo, manager);
508     EventFwk::CommonEventData data;
509     Want want;
510     want.SetAction(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
511     data.SetWant(want);
512     subscriber->OnReceiveEvent(data);
513     want.SetAction(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
514     data.SetWant(want);
515     subscriber->OnReceiveEvent(data);
516     want.SetAction(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
517     data.SetWant(want);
518     subscriber->OnReceiveEvent(data);
519     want.SetAction(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
520     data.SetWant(want);
521     subscriber->OnReceiveEvent(data);
522     want.SetAction(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
523     data.SetWant(want);
524     subscriber->OnReceiveEvent(data);
525     want.SetAction(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
526     data.SetWant(want);
527     subscriber->OnReceiveEvent(data);
528     want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
529     data.SetWant(want);
530     subscriber->OnReceiveEvent(data);
531     want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
532     data.SetWant(want);
533     subscriber->OnReceiveEvent(data);
534     want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
535     data.SetWant(want);
536     subscriber->OnReceiveEvent(data);
537     want.SetAction(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
538     data.SetWant(want);
539     subscriber->OnReceiveEvent(data);
540     want.SetAction(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
541     data.SetWant(want);
542     subscriber->OnReceiveEvent(data);
543     want.SetAction(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
544     data.SetWant(want);
545     subscriber->OnReceiveEvent(data);
546     want.SetAction(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
547     data.SetWant(want);
548     subscriber->OnReceiveEvent(data);
549     system("rm -rf /data/service/el1/public/notification/");
550     EXPECT_TRUE(manager != nullptr);
551 }
552 
553 /**
554  * @tc.name: ReminderEventManagerTest_002
555  * @tc.desc: Reminder data manager test
556  * @tc.type: FUNC
557  * @tc.require: issueI5YTF3
558  */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_002,Level1)559 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_002, Level1)
560 {
561     auto statusChangeListener
562         = std::make_shared<ReminderEventManager::SystemAbilityStatusChangeListener>(manager);
563     statusChangeListener->OnAddSystemAbility(0, "");
564     statusChangeListener->OnRemoveSystemAbility(0, "");
565     system("rm -rf /data/service/el1/public/notification/");
566     EXPECT_TRUE(manager != nullptr);
567 }
568 
569 /**
570  * @tc.name: ReminderEventManagerTest_003
571  * @tc.desc: Reminder data manager test
572  * @tc.type: FUNC
573  * @tc.require: issueI5YTF3
574  */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_003,Level1)575 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_003, Level1)
576 {
577     auto timeInfo = std::make_shared<ReminderTimerInfo>();
578     timeInfo->SetType(0);
579     timeInfo->SetRepeat(false);
580     timeInfo->SetInterval(0);
581     timeInfo->SetWantAgent(nullptr);
582     timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALARM_ALERT;
583     timeInfo->OnTrigger();
584     timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT;
585     timeInfo->OnTrigger();
586     system("rm -rf /data/service/el1/public/notification/");
587     EXPECT_TRUE(manager != nullptr);
588 }
589 
590 /**
591  * @tc.name: ReminderEventManagerTest_004
592  * @tc.desc: Reminder data manager test
593  * @tc.type: FUNC
594  * @tc.require: issueI5YTF3
595  */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_004,Level1)596 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_004, Level1)
597 {
598     EventFwk::Want want;
599     manager->HandleCustomButtonClick(want);
600     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
601     manager->reminderVector_.push_back(reminder);
602     want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
603     manager->HandleCustomButtonClick(want);
604     system("rm -rf /data/service/el1/public/notification/");
605     EXPECT_TRUE(manager != nullptr);
606 }
607 
608 /**
609  * @tc.name: StartExtensionAbilityTest_001
610  * @tc.desc: Reminder data manager test
611  * @tc.type: FUNC
612  * @tc.require: issueI92G9T
613  */
HWTEST_F(ReminderDataManagerTest,StartExtensionAbilityTest_001,Level1)614 HWTEST_F(ReminderDataManagerTest, StartExtensionAbilityTest_001, Level1)
615 {
616     auto reminder1 = new ReminderRequestCalendar(10);
617     bool ret1 = manager->StartExtensionAbility(reminder1, 0);
618     EXPECT_TRUE(ret1);
619 
620     auto reminder2 = new ReminderRequestCalendar(10);
621     auto wantInfo = std::make_shared<ReminderRequest::WantAgentInfo>();
622     reminder2->SetRRuleWantAgentInfo(wantInfo);
623     bool ret2 = manager->StartExtensionAbility(reminder2, 0);
624     EXPECT_TRUE(ret2);
625 }
626 
627 /**
628  * @tc.name: IsBelongToSameAppTest_001
629  * @tc.desc: Reminder data manager test
630  * @tc.type: FUNC
631  * @tc.require: issue#I97Q9Q
632  */
HWTEST_F(ReminderDataManagerTest,IsBelongToSameAppTest_001,Level1)633 HWTEST_F(ReminderDataManagerTest, IsBelongToSameAppTest_001, Level1)
634 {
635     sptr<NotificationBundleOption> option1 = new NotificationBundleOption("test", 100);
636     sptr<NotificationBundleOption> option2 = new NotificationBundleOption("test", 100);
637     EXPECT_TRUE(manager->IsBelongToSameApp(option1, option2));
638 
639     option2->SetUid(101);
640     EXPECT_FALSE(manager->IsBelongToSameApp(option1, option2));
641 
642     option2->SetUid(100);
643     option2->SetBundleName("test1");
644     EXPECT_FALSE(manager->IsBelongToSameApp(option1, option2));
645 }
646 
647 /**
648  * @tc.name: CheckIsSameAppTest_001
649  * @tc.desc: Reminder data manager test
650  * @tc.type: FUNC
651  * @tc.require: issue#I97Q9Q
652  */
HWTEST_F(ReminderDataManagerTest,CheckIsSameAppTest_001,Level1)653 HWTEST_F(ReminderDataManagerTest, CheckIsSameAppTest_001, Level1)
654 {
655     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
656     reminder->InitCreatorBundleName("test");
657     reminder->InitUserId(-1);
658     sptr<NotificationBundleOption> option = new NotificationBundleOption("test", -1);
659     EXPECT_TRUE(manager->CheckIsSameApp(reminder, option));
660 
661     reminder->InitCreatorBundleName("test1");
662     EXPECT_FALSE(manager->CheckIsSameApp(reminder, option));
663 }
664 
665 /**
666  * @tc.name: CheckPulishReminder
667  * @tc.desc: Reminder data manager test
668  * @tc.type: FUNC
669  * @tc.require: issue#I97Q9Q
670  */
HWTEST_F(ReminderDataManagerTest,CheckPulishReminder_0001,Level1)671 HWTEST_F(ReminderDataManagerTest, CheckPulishReminder_0001, Level1)
672 {
673     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
674     sptr<NotificationBundleOption> option = new NotificationBundleOption();
675     IPCSkeleton::SetCallingTokenID(0);
676     ErrCode ret = manager->PublishReminder(reminder, option);
677     ASSERT_EQ(ret, ERR_REMINDER_CALLER_TOKEN_INVALID);
678 
679     IPCSkeleton::SetCallingTokenID(1);
680     ret = manager->PublishReminder(reminder, option);
681     EXPECT_NE(ret, ERR_REMINDER_DATA_SHARE_PERMISSION_DENIED);
682 }
683 
684 /**
685  * @tc.name: OnLanguageChanged
686  * @tc.desc: Reminder data manager test
687  * @tc.type: FUNC
688  * @tc.require: issue#I97Q9Q
689  */
HWTEST_F(ReminderDataManagerTest,OnLanguageChanged_0001,Level1)690 HWTEST_F(ReminderDataManagerTest, OnLanguageChanged_0001, Level1)
691 {
692     sleep(2);
693     sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
694     reminder->SetReminderId(10);
695     std::string title = "this is title";
696     std::string resource = "close";
697     ReminderRequest::ActionButtonType type = ReminderRequest::ActionButtonType::CLOSE;
698     reminder->SetActionButton(title, type, resource);
699 
700     manager->reminderVector_.push_back(reminder);
701     manager->showedReminderVector_.push_back(reminder);
702 
703     manager->OnLanguageChanged();
704     EXPECT_TRUE(reminder->actionButtonMap_[type].title == "this is title");
705 }
706 
707 /**
708  * @tc.name: ExcludeDate
709  * @tc.desc: Reminder data manager test
710  * @tc.type: FUNC
711  * @tc.require: issue#I97Q9Q
712  */
HWTEST_F(ReminderDataManagerTest,ExcludeDate_0001,Level1)713 HWTEST_F(ReminderDataManagerTest, ExcludeDate_0001, Level1)
714 {
715     std::vector<uint64_t> dates;
716     auto result = manager->CheckExcludeDateParam(9999, nullptr);
717     EXPECT_TRUE(result == nullptr);
718 
719     auto ret = manager->AddExcludeDate(9999, 100, nullptr);
720     EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
721 
722     ret = manager->DelExcludeDates(9999, nullptr);
723     EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
724 
725     ret = manager->GetExcludeDates(9999, nullptr, dates);
726     EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
727 
728     sptr<ReminderRequest> reminder = new ReminderRequestCalendar(10);
729     reminder->InitCreatorBundleName("test1");
730     reminder->InitUserId(-1);
731     reminder->reminderId_ = 100;
732     manager->reminderVector_.push_back(reminder);
733     sptr<NotificationBundleOption> option = new NotificationBundleOption("test", -1);
734     result = manager->CheckExcludeDateParam(100, option);
735     EXPECT_TRUE(result == nullptr);
736 
737     reminder->InitCreatorBundleName("test");
738     reminder->reminderType_ = ReminderRequest::ReminderType::TIMER;
739     result = manager->CheckExcludeDateParam(100, option);
740     EXPECT_TRUE(result == nullptr);
741 
742     reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
743     result = manager->CheckExcludeDateParam(100, option);
744     EXPECT_TRUE(result == nullptr);
745 
746     reminder->repeatDaysOfWeek_ = 1;
747     result = manager->CheckExcludeDateParam(100, option);
748     EXPECT_TRUE(result != nullptr);
749 
750     ret = manager->AddExcludeDate(100, 100, option);
751     EXPECT_TRUE(ret == ERR_OK);
752 
753     ret = manager->DelExcludeDates(100, option);
754     EXPECT_TRUE(ret == ERR_OK);
755 
756     ret = manager->GetExcludeDates(100, option, dates);
757     EXPECT_TRUE(ret == ERR_OK);
758 }
759 
760 /**
761  * @tc.name: InitStartExtensionAbility
762  * @tc.desc: Reminder data manager test
763  * @tc.type: FUNC
764  * @tc.require: issue#I9IIDE
765  */
HWTEST_F(ReminderDataManagerTest,InitStartExtensionAbility_0001,Level1)766 HWTEST_F(ReminderDataManagerTest, InitStartExtensionAbility_0001, Level1)
767 {
768     sptr<ReminderRequest> reminder = new ReminderRequestCalendar(10);
769     reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
770     ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
771     uint64_t now = calendar->GetNowInstantMilli();
772     calendar->SetDateTime(now-50000);
773     calendar->SetEndDateTime(now+50000);
774     manager->reminderVector_.push_back(calendar);
775     manager->Init(true);
776     EXPECT_TRUE(!manager->reminderVector_.empty());
777 }
778 
779 /**
780  * @tc.name: ReminderNotificationSubscriber_00001
781  * @tc.desc: Reminder data manager test
782  * @tc.type: FUNC
783  * @tc.require: issue#I9IIDE
784  */
HWTEST_F(ReminderDataManagerTest,ReminderNotificationSubscriber_00001,Level1)785 HWTEST_F(ReminderDataManagerTest, ReminderNotificationSubscriber_00001, Level1)
786 {
787     ReminderEventManager::ReminderNotificationSubscriber test(manager);
788     sptr<NotificationRequest> notificationReq = new NotificationRequest();
789     std::shared_ptr<Notification> notification = std::make_shared<Notification>(notificationReq);
790     test.OnCanceled(notification, nullptr, NotificationConstant::CANCEL_REASON_DELETE);
791     SUCCEED();
792 
793     test.OnCanceled(nullptr, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
794     SUCCEED();
795 
796     notificationReq->SetLabel("");
797     test.OnCanceled(notification, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
798     SUCCEED();
799 
800     notificationReq->SetLabel("TEST_1");
801     test.OnCanceled(notification, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
802     SUCCEED();
803 
804     notificationReq->SetLabel("TEST_NOTIFICATION_1");
805     test.OnCanceled(notification, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
806     SUCCEED();
807 
808     notificationReq->SetLabel("REMINDER_NOTIFICATION_1");
809     test.OnCanceled(notification, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
810     SUCCEED();
811 
812     notificationReq->SetLabel("REMINDER_AGENT_INFO");
813     test.OnCanceled(notification, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
814     SUCCEED();
815 
816     notificationReq->SetLabel("REMINDER_AGENT_0");
817     test.OnCanceled(notification, nullptr, NotificationConstant::APP_CANCEL_REASON_DELETE);
818     SUCCEED();
819 }
820 
821 /**
822  * @tc.name: CancelAllReminders_00001
823  * @tc.desc: Reminder data manager test
824  * @tc.type: FUNC
825  * @tc.require: issue#I9IIDE
826  */
HWTEST_F(ReminderDataManagerTest,CancelAllReminders_00001,Level1)827 HWTEST_F(ReminderDataManagerTest, CancelAllReminders_00001, Level1)
828 {
829     int32_t ret = manager->CancelAllReminders("", -1, -1);
830     EXPECT_TRUE(ret == ERR_OK);
831 
832     ret = manager->CancelAllReminders("com.example.simple", 100, 20020152);
833     EXPECT_TRUE(ret == ERR_OK);
834 }
835 
836 /**
837  * @tc.name: GetVaildReminders_00001
838  * @tc.desc: Reminder data manager test
839  * @tc.type: FUNC
840  * @tc.require: issue#I9IIDE
841  */
HWTEST_F(ReminderDataManagerTest,GetVaildReminders_00001,Level1)842 HWTEST_F(ReminderDataManagerTest, GetVaildReminders_00001, Level1)
843 {
844     sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(static_cast<uint64_t>(50));
845     reminder1->InitCreatorBundleName("test_getvalid");
846     reminder1->InitCreatorUid(98765);
847     reminder1->InitBundleName("test_getvalid");
848     reminder1->InitUid(98765);
849     sptr<NotificationBundleOption> option1 = new NotificationBundleOption("test_getvalid", 98765);
850     manager->PublishReminder(reminder1, option1);
851     reminder1->SetExpired(false);
852 
853     sptr<ReminderRequest> reminder2 = new ReminderRequestTimer(51);
854     reminder2->InitCreatorBundleName("test_getvalid");
855     reminder2->InitCreatorUid(98765);
856     reminder2->InitBundleName("test_getvalid");
857     reminder2->InitUid(98765);
858     reminder2->SetExpired(true);
859     sptr<NotificationBundleOption> option2 = new NotificationBundleOption("test_getvalid", 98765);
860     manager->PublishReminder(reminder2, option2);
861 
862     std::vector<sptr<ReminderRequest>> reminders;
863     manager->GetValidReminders(option2, reminders);
864     EXPECT_TRUE(reminders.size() == 1);
865 }
866 
867 /**
868  * @tc.name: IsMatched_00001
869  * @tc.desc: Reminder data manager test
870  * @tc.type: FUNC
871  * @tc.require: issue#I9IIDE
872  */
HWTEST_F(ReminderDataManagerTest,IsMatched_00001,Level1)873 HWTEST_F(ReminderDataManagerTest, IsMatched_00001, Level1)
874 {
875     sptr<ReminderRequest> reminder = new ReminderRequestTimer(50);
876     reminder->InitCreatorBundleName("test_IsMatched");
877     reminder->InitCreatorUid(98765);
878     reminder->InitBundleName("test_IsMatched");
879     reminder->InitUid(98765);
880     reminder->InitUserId(100);
881     bool ret = manager->IsMatched(reminder, "test_IsMatched", 101, 98765);
882     EXPECT_EQ(ret, false);
883     ret = manager->IsMatched(reminder, "allPackages", 100, 98765);
884     EXPECT_EQ(ret, true);
885     ret = manager->IsMatched(reminder, "test_IsMatched2", 100, 98765);
886     EXPECT_EQ(ret, false);
887     ret = manager->IsMatched(reminder, "test_IsMatched", 100, -1);
888     EXPECT_EQ(ret, false);
889     ret = manager->IsMatched(reminder, "test_IsMatched", 100, 98766);
890     EXPECT_EQ(ret, false);
891     ret = manager->IsMatched(reminder, "test_IsMatched", 100, 98765);
892     EXPECT_EQ(ret, true);
893 }
894 }  // namespace Notification
895 }  // namespace OHOS
896