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 #include "common_event_data.h"
21 #include "common_event_manager.h"
22 #include "common_event_support.h"
23 #include "matching_skills.h"
24 #include "reminder_data_manager.h"
25 #include "reminder_event_manager.h"
26 #include "reminder_request_timer.h"
27 #include "reminder_request_alarm.h"
28 #include "reminder_request.h"
29 #include "reminder_request_adaptation.h"
30 #include "reminder_request_calendar.h"
31 #include "ability_manager_client.h"
32 #include "mock_ipc_skeleton.h"
33 #include "reminder_datashare_helper.h"
34 #include "reminder_config_change_observer.h"
35 #include "reminder_calendar_share_table.h"
36 #include "reminder_timer_info.h"
37
38 using namespace testing::ext;
39 using namespace OHOS::EventFwk;
40 namespace OHOS {
41 namespace Notification {
42 class ReminderDataManagerTest : public testing::Test {
43 public:
SetUpTestCase()44 static void SetUpTestCase()
45 {
46 ReminderDataManager::InitInstance();
47 manager = ReminderDataManager::GetInstance();
48 manager->RegisterConfigurationObserver();
49 manager->Init();
50 }
TearDownTestCase()51 static void TearDownTestCase()
52 {
53 manager->showedReminderVector_.clear();
54 manager = nullptr;
55 }
SetUp()56 void SetUp() {};
TearDown()57 void TearDown() {};
58
59 public:
60 static std::shared_ptr<ReminderDataManager> manager;
61 };
62
63 std::shared_ptr<ReminderDataManager> ReminderDataManagerTest::manager = nullptr;
64
65 /**
66 * @tc.name: GetVaildReminders_00001
67 * @tc.desc: Reminder data manager test
68 * @tc.type: FUNC
69 * @tc.require: issue#I9IIDE
70 */
HWTEST_F(ReminderDataManagerTest,GetVaildReminders_00001,Level1)71 HWTEST_F(ReminderDataManagerTest, GetVaildReminders_00001, Level1)
72 {
73 IPCSkeleton::SetCallingTokenID(100);
74 manager->store_->Init();
75 int32_t callingUid = 98765;
76 sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(static_cast<uint64_t>(50));
77 reminder1->InitCreatorBundleName("test_getvalid");
78 reminder1->InitCreatorUid(callingUid);
79 reminder1->InitBundleName("test_getvalid");
80 reminder1->InitUid(callingUid);
81 reminder1->SetExpired(false);
82 manager->PublishReminder(reminder1, callingUid);
83
84 sptr<ReminderRequest> reminder2 = new ReminderRequestTimer(51);
85 reminder2->InitCreatorBundleName("test_getvalid");
86 reminder2->InitCreatorUid(callingUid);
87 reminder2->InitBundleName("test_getvalid");
88 reminder2->InitUid(callingUid);
89 reminder2->SetExpired(true);
90 manager->PublishReminder(reminder2, callingUid);
91
92 std::vector<ReminderRequestAdaptation> reminders;
93 manager->GetValidReminders(callingUid, reminders);
94 EXPECT_TRUE(reminders.size() >= 0);
95 }
96
97 /**
98 * @tc.name: ReminderDataManagerTest_001
99 * @tc.desc: Reminder data manager test
100 * @tc.type: FUNC
101 * @tc.require: issueI5YTF3
102 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_001,Level1)103 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_001, Level1)
104 {
105 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
106 int32_t reminderId = -1;
107 manager->PublishReminder(reminder, reminderId);
108 manager->CancelReminder(reminderId, -1);
109 manager->CancelAllReminders("", -1, -1);
110 manager->CancelAllReminders(-1);
111 manager->IsMatched(reminder, -1, -1, true);
112 system("rm -rf /data/service/el1/public/notification/");
113 EXPECT_TRUE(manager != nullptr);
114 }
115
116 /**
117 * @tc.name: ReminderDataManagerTest_002
118 * @tc.desc: Reminder data manager test
119 * @tc.type: FUNC
120 * @tc.require: issueI5YTF3
121 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_002,Level1)122 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_002, Level1)
123 {
124 int32_t callingUid = -1;
125 std::vector<ReminderRequestAdaptation> vec;
126 manager->GetValidReminders(callingUid, vec);
127 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
128
129 manager->CheckReminderLimitExceededLocked(callingUid, reminder);
130 manager->CancelNotification(reminder);
131 reminder->SetReminderId(10);
132 manager->AddToShowedReminders(reminder);
133 manager->AddToShowedReminders(reminder);
134 system("rm -rf /data/service/el1/public/notification/");
135 EXPECT_TRUE(manager != nullptr);
136 }
137
138 /**
139 * @tc.name: ReminderDataManagerTest_003
140 * @tc.desc: Reminder data manager test
141 * @tc.type: FUNC
142 * @tc.require: issueI5YTF3
143 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_003,Level1)144 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_003, Level1)
145 {
146 manager->isReminderAgentReady_ = false;
147 manager->alertingReminderId_ = -1;
148 manager->OnUserSwitch(0);
149 manager->OnUserRemove(0);
150 manager->alertingReminderId_ = 1;
151 manager->OnUserSwitch(0);
152 manager->isReminderAgentReady_ = true;
153 manager->OnUserSwitch(0);
154 manager->alertingReminderId_ = -1;
155 manager->OnUserSwitch(0);
156 manager->OnUserRemove(0);
157 manager->OnBundleMgrServiceStart();
158 manager->OnAbilityMgrServiceStart();
159 system("rm -rf /data/service/el1/public/notification/");
160 EXPECT_TRUE(manager != nullptr);
161 }
162
163 /**
164 * @tc.name: ReminderDataManagerTest_004
165 * @tc.desc: Reminder data manager test
166 * @tc.type: FUNC
167 * @tc.require: issueI5YTF3
168 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_004,Level1)169 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_004, Level1)
170 {
171 manager->showedReminderVector_.clear();
172 int32_t callingUid = -1;
173 manager->OnProcessDiedLocked(callingUid);
174 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
175 manager->CreateTimerInfo(ReminderDataManager::TimerType::TRIGGER_TIMER, reminder);
176 manager->CreateTimerInfo(ReminderDataManager::TimerType::ALERTING_TIMER, reminder);
177 manager->FindReminderRequestLocked(0, false);
178 reminder->SetReminderId(10);
179 manager->reminderVector_.push_back(reminder);
180 manager->FindReminderRequestLocked(10, false);
181 manager->FindReminderRequestLocked(10, false);
182 manager->FindReminderRequestLocked(10, false);
183 system("rm -rf /data/service/el1/public/notification/");
184 EXPECT_TRUE(manager != nullptr);
185 }
186
187 /**
188 * @tc.name: ReminderDataManagerTest_005
189 * @tc.desc: Reminder data manager test
190 * @tc.type: FUNC
191 * @tc.require: issueI5YTF3
192 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_005,Level1)193 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_005, Level1)
194 {
195 EventFwk::Want want;
196 manager->CloseReminder(want, true);
197 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
198 reminder->SetReminderId(1);
199 manager->activeReminderId_ = 1;
200 manager->activeReminder_ = reminder;
201 manager->CloseReminder(reminder, true);
202 reminder->SetReminderId(2);
203 manager->alertingReminderId_ = 2;
204 manager->CloseReminder(reminder, true);
205 reminder->SetReminderId(3);
206 manager->CloseReminder(reminder, true);
207 manager->CloseReminder(reminder, false);
208 reminder->SetReminderId(4);
209 reminder->SetGroupId("");
210 manager->CloseReminder(reminder, true);
211 system("rm -rf /data/service/el1/public/notification/");
212 EXPECT_TRUE(manager != nullptr);
213 }
214
215 /**
216 * @tc.name: ReminderDataManagerTest_006
217 * @tc.desc: Reminder data manager test
218 * @tc.type: FUNC
219 * @tc.require: issueI5YTF3
220 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_006,Level1)221 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_006, Level1)
222 {
223 manager->RefreshRemindersDueToSysTimeChange(0);
224 manager->RefreshRemindersDueToSysTimeChange(1);
225 manager->activeReminderId_ = 1;
226 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
227 manager->activeReminder_ = reminder;
228 manager->RefreshRemindersDueToSysTimeChange(1);
229 system("rm -rf /data/service/el1/public/notification/");
230 EXPECT_TRUE(manager != nullptr);
231 }
232
233 /**
234 * @tc.name: ReminderDataManagerTest_007
235 * @tc.desc: Reminder data manager test
236 * @tc.type: FUNC
237 * @tc.require: issueI5YTF3
238 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_007,Level1)239 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_007, Level1)
240 {
241 EventFwk::Want want;
242 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
243 manager->ShowActiveReminder(want);
244 manager->CloseReminder(want, true);
245 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
246 reminder->SetReminderId(10);
247 manager->reminderVector_.push_back(reminder);
248 manager->ShowActiveReminder(want);
249 manager->activeReminderId_ = 10;
250 manager->activeReminder_ = reminder;
251 manager->ShowActiveReminder(want);
252 manager->CloseReminder(want, true);
253 system("rm -rf /data/service/el1/public/notification/");
254 EXPECT_TRUE(manager != nullptr);
255 }
256
257 /**
258 * @tc.name: ReminderDataManagerTest_008
259 * @tc.desc: Reminder data manager test
260 * @tc.type: FUNC
261 * @tc.require: issueI5YTF3
262 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_008,Level1)263 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_008, Level1)
264 {
265 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
266 manager->TerminateAlerting(0, reminder);
267 manager->TerminateAlerting(nullptr, "");
268 manager->TerminateAlerting(reminder, "");
269 reminder->state_ = 2;
270 manager->TerminateAlerting(reminder, "");
271 system("rm -rf /data/service/el1/public/notification/");
272 EXPECT_TRUE(manager != nullptr);
273 }
274
275 /**
276 * @tc.name: ReminderDataManagerTest_009
277 * @tc.desc: Reminder data manager test
278 * @tc.type: FUNC
279 * @tc.require: issueI5YTF3
280 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_009,Level1)281 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_009, Level1)
282 {
283 int32_t callingUid = -1;
284 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
285 manager->UpdateAndSaveReminderLocked(reminder);
286 sptr<ReminderAgentService> service(new ReminderAgentService);
287 manager->ShouldAlert(nullptr);
288 manager->currentUserId_ = 0;
289 manager->ShouldAlert(reminder);
290 system("rm -rf /data/service/el1/public/notification/");
291 EXPECT_TRUE(manager != nullptr);
292 }
293
294 /**
295 * @tc.name: ReminderDataManagerTest_010
296 * @tc.desc: Reminder data manager test
297 * @tc.type: FUNC
298 * @tc.require: issueI5YTF3
299 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_010,Level1)300 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_010, Level1)
301 {
302 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
303 manager->HandleSysTimeChange(reminder);
304 manager->SetActiveReminder(nullptr);
305 manager->SetActiveReminder(reminder);
306 manager->SetAlertingReminder(nullptr);
307 manager->SetAlertingReminder(reminder);
308 system("rm -rf /data/service/el1/public/notification/");
309 EXPECT_TRUE(manager != nullptr);
310 }
311
312 /**
313 * @tc.name: ReminderDataManagerTest_011
314 * @tc.desc: Reminder data manager test
315 * @tc.type: FUNC
316 * @tc.require: issueI5YTF3
317 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_011,Level1)318 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_011, Level1)
319 {
320 sptr<ReminderRequest> reminder(new ReminderRequestTimer(10));
321 reminder->SetReminderId(0);
322 manager->ShowReminder(reminder, true, true, true, true);
323 reminder->SetReminderId(10);
324 manager->ShowReminder(reminder, true, true, true, true);
325 manager->ShowReminder(reminder, true, true, true, true);
326 manager->alertingReminderId_ = 1;
327 manager->ShowReminder(reminder, true, true, true, true);
328 manager->alertingReminderId_ = -1;
329 manager->ShowReminder(reminder, true, true, true, true);
330 system("rm -rf /data/service/el1/public/notification/");
331 EXPECT_TRUE(manager != nullptr);
332 }
333
334 /**
335 * @tc.name: ReminderDataManagerTest_012
336 * @tc.desc: Reminder data manager test
337 * @tc.type: FUNC
338 * @tc.require: issueI5YTF3
339 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_012,Level1)340 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_012, Level1)
341 {
342 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
343 manager->activeReminderId_ = 10;
344 manager->activeReminder_ = reminder;
345 reminder->SetReminderId(10);
346 manager->activeReminderId_ = 1;
347 system("rm -rf /data/service/el1/public/notification/");
348 EXPECT_TRUE(manager != nullptr);
349 }
350
351 /**
352 * @tc.name: ReminderDataManagerTest_013
353 * @tc.desc: Reminder data manager test
354 * @tc.type: FUNC
355 * @tc.require: issueI5YTF3
356 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_013,Level1)357 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_013, Level1)
358 {
359 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
360 manager->activeReminderId_ = 10;
361 manager->activeReminder_ = reminder;
362 reminder->SetReminderId(10);
363 system("rm -rf /data/service/el1/public/notification/");
364 EXPECT_TRUE(manager != nullptr);
365 }
366
367 /**
368 * @tc.name: ReminderDataManagerTest_014
369 * @tc.desc: Reminder data manager test
370 * @tc.type: FUNC
371 * @tc.require: issueI5YTF3
372 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_014,Level1)373 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_014, Level1)
374 {
375 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
376 reminder->SetReminderId(0);
377 manager->StartRecentReminder();
378 manager->StopAlertingReminder(nullptr);
379 manager->alertingReminderId_ = -1;
380 manager->StopAlertingReminder(reminder);
381 manager->alertingReminderId_ = 1;
382 manager->StopAlertingReminder(reminder);
383 reminder->SetReminderId(1);
384 manager->StopAlertingReminder(reminder);
385 manager->Dump();
386 system("rm -rf /data/service/el1/public/notification/");
387 EXPECT_TRUE(manager != nullptr);
388 }
389
390 /**
391 * @tc.name: ReminderDataManagerTest_015
392 * @tc.desc: Reminder data manager test
393 * @tc.type: FUNC
394 * @tc.require: issueI5YTF3
395 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_015,Level1)396 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_015, Level1)
397 {
398 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
399 std::vector<sptr<ReminderRequest>> vec;
400 vec.push_back(reminder);
401 manager->HandleImmediatelyShow(vec, true);
402 manager->HandleRefreshReminder(0, reminder);
403 manager->HandleSameNotificationIdShowing(reminder);
404 manager->Init();
405 manager->InitUserId();
406 manager->GetImmediatelyShowRemindersLocked(vec);
407 manager->IsAllowedNotify(reminder);
408 manager->IsAllowedNotify(nullptr);
409 manager->IsReminderAgentReady();
410 system("rm -rf /data/service/el1/public/notification/");
411 EXPECT_TRUE(manager != nullptr);
412 }
413
414 /**
415 * @tc.name: ReminderDataManagerTest_016
416 * @tc.desc: Reminder data manager test
417 * @tc.type: FUNC
418 * @tc.require: issuesI8CAQB
419 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_016,Level1)420 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_016, Level1)
421 {
422 // not SystemApp
423 std::vector<uint8_t> daysOfWeek;
424 sptr<ReminderRequest> reminder = new ReminderRequestAlarm(0, 1, daysOfWeek);
425 std::shared_ptr<ReminderRequest::ButtonWantAgent> buttonWantAgent =
426 std::make_shared<ReminderRequest::ButtonWantAgent>();
427 std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> buttonDataShareUpdate =
428 std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
429 reminder->SetSystemApp(false);
430 reminder->SetActionButton("不再提醒", ReminderRequest::ActionButtonType::CLOSE,
431 "", buttonWantAgent, buttonDataShareUpdate);
432 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::CLOSE);
433
434 // INVALID ActionButtonType
435 reminder->SetSystemApp(true);
436 reminder->SetActionButton("无效的", ReminderRequest::ActionButtonType::INVALID,
437 "", buttonWantAgent, buttonDataShareUpdate);
438 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::INVALID);
439
440 // actionButtonType does not exist
441 std::map<ReminderRequest::ActionButtonType, ReminderRequest::ActionButtonInfo> actionButtonMap;
442 manager->CheckUpdateConditions(reminder, ReminderRequest::ActionButtonType::CLOSE, actionButtonMap);
443
444 // null ButtonDataShareUpdate
445 reminder->SetActionButton("稍后提醒", ReminderRequest::ActionButtonType::SNOOZE, "", buttonWantAgent);
446 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::SNOOZE);
447
448 // not have uri
449 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::CLOSE);
450
451 // update datashare
452 sptr<ReminderRequest> reminder1 = new ReminderRequestAlarm(2, 3, daysOfWeek);
453 std::shared_ptr<ReminderRequest::ButtonWantAgent> buttonWantAgent1 =
454 std::make_shared<ReminderRequest::ButtonWantAgent>();
455 std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> buttonDataShareUpdate1 =
456 std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
457 reminder1->SetSystemApp(true);
458 reminder1->InitUserId(100);
459 buttonDataShareUpdate1->uri = "datashareTest://com.acts.dataShareTest";
460 buttonDataShareUpdate1->equalTo = "name<SEP:/>string<SEP:/>li<SEP;/>"
461 "id<SEP:/>double<SEP:/>3.0<SEP;/>status<SEP:/>bool<SEP:/>true";
462 buttonDataShareUpdate1->valuesBucket = "name<SEP:/>string<SEP:/>wang<SEP;/>"
463 "id<SEP:/>double<SEP:/>4.0<SEP;/>status<SEP:/>bool<SEP:/>true<SEP;/>actionId<SEP:/>null<SEP:/>null";
464 reminder1->SetActionButton("不再提醒", ReminderRequest::ActionButtonType::CLOSE, "",
465 buttonWantAgent1, buttonDataShareUpdate1);
466 manager->UpdateAppDatabase(reminder1, ReminderRequest::ActionButtonType::CLOSE);
467 EXPECT_TRUE(reminder1->actionButtonMap_.size() > 0);
468 }
469
470 /**
471 * @tc.name: ReminderDataManagerTest_017
472 * @tc.desc: Reminder data manager test
473 * @tc.type: FUNC
474 * @tc.require: issueI8CDH3
475 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_017,Level1)476 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_017, Level1)
477 {
478 IPCSkeleton::SetCallingTokenID(1);
479 sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(10);
480 sptr<ReminderRequest> reminder2 = new ReminderRequestTimer(10);
481 sptr<ReminderRequest> reminder3 = new ReminderRequestTimer(10);
482 int32_t callingUid = 1;
483 reminder1->SetReminderId(1);
484 reminder2->SetReminderId(2);
485 reminder3->SetReminderId(3);
486 reminder1->SetGroupId("123");
487 reminder2->SetGroupId("123");
488 reminder3->SetGroupId("124");
489 manager->PublishReminder(reminder1, callingUid);
490 manager->PublishReminder(reminder2, callingUid);
491 manager->PublishReminder(reminder3, callingUid);
492 manager->CloseRemindersByGroupId(1, "test", "123");
493 system("rm -rf /data/service/el1/public/notification/");
494 EXPECT_TRUE(reminder2->isExpired_);
495 }
496
497 /**
498 * @tc.name: ReminderDataManagerTest_018
499 * @tc.desc: Reminder data manager test
500 * @tc.type: FUNC
501 * @tc.require: issueI8E7Z1
502 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_018,Level1)503 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_018, Level1)
504 {
505 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
506 std::string ringUri = "123";
507 reminder->SetCustomRingUri(ringUri);
508 std::string getRingUri = reminder->GetCustomRingUri();
509 ASSERT_EQ(ringUri, getRingUri);
510 }
511
512 /**
513 * @tc.name: ReminderEventManagerTest_001
514 * @tc.desc: Reminder data manager test
515 * @tc.type: FUNC
516 * @tc.require: issueI5YTF3
517 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_001,Level1)518 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_001, Level1)
519 {
520 MatchingSkills matchingSkills;
521 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
522 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
523 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
524 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
525 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
526 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
527 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
528 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
529 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
530 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
531 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
532 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
533 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
534 auto subscriber = std::make_shared<ReminderEventManager::ReminderEventSubscriber>(subscriberInfo, manager);
535 EventFwk::CommonEventData data;
536 Want want;
537 want.SetAction(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
538 data.SetWant(want);
539 subscriber->OnReceiveEvent(data);
540 want.SetAction(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
541 data.SetWant(want);
542 subscriber->OnReceiveEvent(data);
543 want.SetAction(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
544 data.SetWant(want);
545 subscriber->OnReceiveEvent(data);
546 want.SetAction(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
547 data.SetWant(want);
548 subscriber->OnReceiveEvent(data);
549 want.SetAction(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
550 data.SetWant(want);
551 subscriber->OnReceiveEvent(data);
552 want.SetAction(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
553 data.SetWant(want);
554 subscriber->OnReceiveEvent(data);
555 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
556 data.SetWant(want);
557 subscriber->OnReceiveEvent(data);
558 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
559 data.SetWant(want);
560 subscriber->OnReceiveEvent(data);
561 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
562 data.SetWant(want);
563 subscriber->OnReceiveEvent(data);
564 want.SetAction(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
565 data.SetWant(want);
566 subscriber->OnReceiveEvent(data);
567 want.SetAction(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
568 data.SetWant(want);
569 subscriber->OnReceiveEvent(data);
570 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
571 data.SetWant(want);
572 subscriber->OnReceiveEvent(data);
573 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
574 data.SetWant(want);
575 subscriber->OnReceiveEvent(data);
576 system("rm -rf /data/service/el1/public/notification/");
577 EXPECT_TRUE(manager != nullptr);
578 }
579
580 /**
581 * @tc.name: ReminderEventManagerTest_002
582 * @tc.desc: Reminder data manager test
583 * @tc.type: FUNC
584 * @tc.require: issueI5YTF3
585 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_002,Level1)586 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_002, Level1)
587 {
588 auto statusChangeListener
589 = std::make_shared<ReminderEventManager::SystemAbilityStatusChangeListener>(manager);
590 statusChangeListener->OnAddSystemAbility(0, "");
591 statusChangeListener->OnRemoveSystemAbility(0, "");
592 system("rm -rf /data/service/el1/public/notification/");
593 EXPECT_TRUE(manager != nullptr);
594 }
595
596 /**
597 * @tc.name: ReminderEventManagerTest_003
598 * @tc.desc: Reminder data manager test
599 * @tc.type: FUNC
600 * @tc.require: issueI5YTF3
601 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_003,Level1)602 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_003, Level1)
603 {
604 auto timeInfo = std::make_shared<ReminderTimerInfo>();
605 timeInfo->SetType(0);
606 timeInfo->SetRepeat(false);
607 timeInfo->SetInterval(0);
608 timeInfo->SetWantAgent(nullptr);
609 timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALARM_ALERT;
610 timeInfo->OnTrigger();
611 timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT;
612 timeInfo->OnTrigger();
613 system("rm -rf /data/service/el1/public/notification/");
614 EXPECT_TRUE(manager != nullptr);
615 }
616
617 /**
618 * @tc.name: ReminderEventManagerTest_004
619 * @tc.desc: Reminder data manager test
620 * @tc.type: FUNC
621 * @tc.require: issueI5YTF3
622 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_004,Level1)623 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_004, Level1)
624 {
625 EventFwk::Want want;
626 manager->HandleCustomButtonClick(want);
627 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
628 manager->reminderVector_.push_back(reminder);
629 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
630 manager->HandleCustomButtonClick(want);
631 system("rm -rf /data/service/el1/public/notification/");
632 EXPECT_TRUE(manager != nullptr);
633 }
634
635 /**
636 * @tc.name: StartExtensionAbilityTest_001
637 * @tc.desc: Reminder data manager test
638 * @tc.type: FUNC
639 * @tc.require: issueI92G9T
640 */
HWTEST_F(ReminderDataManagerTest,StartExtensionAbilityTest_001,Level1)641 HWTEST_F(ReminderDataManagerTest, StartExtensionAbilityTest_001, Level1)
642 {
643 auto reminder1 = new ReminderRequestCalendar(10);
644 bool ret1 = manager->StartExtensionAbility(reminder1, 0);
645 EXPECT_TRUE(ret1);
646
647 auto reminder2 = new ReminderRequestCalendar(10);
648 auto wantInfo = std::make_shared<ReminderRequest::WantAgentInfo>();
649 reminder2->SetRRuleWantAgentInfo(wantInfo);
650 bool ret2 = manager->StartExtensionAbility(reminder2, 0);
651 EXPECT_TRUE(ret2);
652 }
653
654 /**
655 * @tc.name: IsBelongToSameAppTest_001
656 * @tc.desc: Reminder data manager test
657 * @tc.type: FUNC
658 * @tc.require: issue#I97Q9Q
659 */
HWTEST_F(ReminderDataManagerTest,IsBelongToSameAppTest_001,Level1)660 HWTEST_F(ReminderDataManagerTest, IsBelongToSameAppTest_001, Level1)
661 {
662 int32_t uidSrc = 100;
663 int32_t uidTar = 100;
664 EXPECT_TRUE(manager->IsBelongToSameApp(uidSrc, uidTar));
665
666 uidTar = 101;
667 EXPECT_FALSE(manager->IsBelongToSameApp(uidSrc, uidTar));
668 }
669
670 /**
671 * @tc.name: CheckIsSameAppTest_001
672 * @tc.desc: Reminder data manager test
673 * @tc.type: FUNC
674 * @tc.require: issue#I97Q9Q
675 */
HWTEST_F(ReminderDataManagerTest,CheckIsSameAppTest_001,Level1)676 HWTEST_F(ReminderDataManagerTest, CheckIsSameAppTest_001, Level1)
677 {
678 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
679 reminder->InitCreatorBundleName("test");
680 int32_t callingUid = 100;
681 reminder->InitCreatorUid(callingUid);
682 EXPECT_TRUE(manager->CheckIsSameApp(reminder, callingUid));
683
684 reminder->InitCreatorUid(-1);
685 EXPECT_FALSE(manager->CheckIsSameApp(reminder, callingUid));
686 }
687
688 /**
689 * @tc.name: CheckPulishReminder
690 * @tc.desc: Reminder data manager test
691 * @tc.type: FUNC
692 * @tc.require: issue#I97Q9Q
693 */
HWTEST_F(ReminderDataManagerTest,CheckPulishReminder_0001,Level1)694 HWTEST_F(ReminderDataManagerTest, CheckPulishReminder_0001, Level1)
695 {
696 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
697 int32_t callingUid = -1;
698 IPCSkeleton::SetCallingTokenID(0);
699 ErrCode ret = manager->PublishReminder(reminder, callingUid);
700 ASSERT_EQ(ret, ERR_REMINDER_CALLER_TOKEN_INVALID);
701
702 IPCSkeleton::SetCallingTokenID(1);
703 ret = manager->PublishReminder(reminder, callingUid);
704 EXPECT_NE(ret, ERR_REMINDER_DATA_SHARE_PERMISSION_DENIED);
705 }
706
707 /**
708 * @tc.name: OnLanguageChanged
709 * @tc.desc: Reminder data manager test
710 * @tc.type: FUNC
711 * @tc.require: issue#I97Q9Q
712 */
HWTEST_F(ReminderDataManagerTest,OnLanguageChanged_0001,Level1)713 HWTEST_F(ReminderDataManagerTest, OnLanguageChanged_0001, Level1)
714 {
715 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
716 reminder->SetReminderId(10);
717 std::string title = "this is title";
718 std::string resource = "close";
719 ReminderRequest::ActionButtonType type = ReminderRequest::ActionButtonType::CLOSE;
720 reminder->SetActionButton(title, type, resource);
721
722 manager->reminderVector_.push_back(reminder);
723 manager->showedReminderVector_.push_back(reminder);
724
725 manager->OnLanguageChanged();
726 EXPECT_TRUE(reminder->actionButtonMap_[type].title == "this is title");
727 }
728
729 /**
730 * @tc.name: ExcludeDate
731 * @tc.desc: Reminder data manager test
732 * @tc.type: FUNC
733 * @tc.require: issue#I97Q9Q
734 */
HWTEST_F(ReminderDataManagerTest,ExcludeDate_0001,Level1)735 HWTEST_F(ReminderDataManagerTest, ExcludeDate_0001, Level1)
736 {
737 std::vector<int64_t> dates;
738 int32_t callingUid = -1;
739 auto result = manager->CheckExcludeDateParam(9999, callingUid);
740 EXPECT_TRUE(result == nullptr);
741
742 auto ret = manager->AddExcludeDate(9999, 100, callingUid);
743 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
744
745 ret = manager->DelExcludeDates(9999, callingUid);
746 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
747
748 ret = manager->GetExcludeDates(9999, callingUid, dates);
749 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
750
751 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(10);
752 reminder->InitCreatorBundleName("test1");
753 reminder->InitUserId(-1);
754 reminder->reminderId_ = 100;
755 manager->reminderVector_.push_back(reminder);
756 result = manager->CheckExcludeDateParam(100, callingUid);
757 EXPECT_TRUE(result == nullptr);
758
759 reminder->InitCreatorBundleName("test");
760 reminder->reminderType_ = ReminderRequest::ReminderType::TIMER;
761 result = manager->CheckExcludeDateParam(100, callingUid);
762 EXPECT_TRUE(result == nullptr);
763
764 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
765 result = manager->CheckExcludeDateParam(100, callingUid);
766 EXPECT_TRUE(result == nullptr);
767
768 reminder->repeatDaysOfWeek_ = 1;
769 result = manager->CheckExcludeDateParam(100, callingUid);
770 EXPECT_TRUE(result != nullptr);
771
772 ret = manager->AddExcludeDate(100, 100, callingUid);
773 EXPECT_TRUE(ret == ERR_OK);
774
775 ret = manager->DelExcludeDates(100, callingUid);
776 EXPECT_TRUE(ret == ERR_OK);
777
778 ret = manager->GetExcludeDates(100, callingUid, dates);
779 EXPECT_TRUE(ret == ERR_OK);
780 }
781
782 /**
783 * @tc.name: InitStartExtensionAbility
784 * @tc.desc: Reminder data manager test
785 * @tc.type: FUNC
786 * @tc.require: issue#I9IIDE
787 */
HWTEST_F(ReminderDataManagerTest,InitStartExtensionAbility_0001,Level1)788 HWTEST_F(ReminderDataManagerTest, InitStartExtensionAbility_0001, Level1)
789 {
790 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(10);
791 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
792 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
793 uint64_t now = calendar->GetNowInstantMilli();
794 calendar->SetDateTime(now-50000);
795 calendar->SetEndDateTime(now+50000);
796 manager->reminderVector_.push_back(calendar);
797 manager->Init();
798 EXPECT_TRUE(!manager->reminderVector_.empty());
799 }
800
801 /**
802 * @tc.name: CancelAllReminders_00001
803 * @tc.desc: Reminder data manager test
804 * @tc.type: FUNC
805 * @tc.require: issue#I9IIDE
806 */
HWTEST_F(ReminderDataManagerTest,CancelAllReminders_00001,Level1)807 HWTEST_F(ReminderDataManagerTest, CancelAllReminders_00001, Level1)
808 {
809 int32_t ret = manager->CancelAllReminders("", -1, -1);
810 EXPECT_TRUE(ret == ERR_OK);
811
812 ret = manager->CancelAllReminders("", 100, 20020152);
813 EXPECT_TRUE(ret == ERR_OK);
814 }
815
816 /**
817 * @tc.name: IsMatched_00001
818 * @tc.desc: Reminder data manager test
819 * @tc.type: FUNC
820 * @tc.require: issue#I9IIDE
821 */
HWTEST_F(ReminderDataManagerTest,IsMatched_00001,Level1)822 HWTEST_F(ReminderDataManagerTest, IsMatched_00001, Level1)
823 {
824 sptr<ReminderRequest> reminder = new ReminderRequestTimer(50);
825 reminder->InitCreatorBundleName("test_IsMatched");
826 reminder->InitCreatorUid(98765);
827 reminder->InitBundleName("test_IsMatched");
828 reminder->InitUid(98765);
829 reminder->InitUserId(100);
830 bool ret = manager->IsMatched(reminder, 101, 98765, true);
831 EXPECT_EQ(ret, false);
832 ret = manager->IsMatched(reminder, 100, 98765, false);
833 EXPECT_EQ(ret, true);
834 ret = manager->IsMatched(reminder, 100, -1, false);
835 EXPECT_EQ(ret, false);
836 ret = manager->IsMatched(reminder, 100, -1, true);
837 EXPECT_EQ(ret, true);
838 }
839
840 /**
841 * @tc.name: ReminderEventManager_00001
842 * @tc.desc: Reminder data manager test
843 * @tc.type: FUNC
844 * @tc.require: issue#I9IIDE
845 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManager_001,Level1)846 HWTEST_F(ReminderDataManagerTest, ReminderEventManager_001, Level1)
847 {
848 MatchingSkills matchingSkills;
849 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
850 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
851 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
852 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
853 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
854 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
855 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
856 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
857 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
858 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
859 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
860 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
861 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
862 auto subscriber = std::make_shared<ReminderEventManager::ReminderEventSubscriber>(subscriberInfo, manager);
863
864 EventFwk::Want want;
865 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 0);
866 AppExecFwk::ElementName element("", "test", "EntryAbility");
867 want.SetElement(element);
868 subscriber->HandlePackageRemove(want);
869 EXPECT_TRUE(manager != nullptr);
870 }
871
872 /**
873 * @tc.name: IsMatched_00001
874 * @tc.desc: Reminder data manager test
875 * @tc.type: FUNC
876 * @tc.require: issue#I9IIDE
877 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManager_002,Level1)878 HWTEST_F(ReminderDataManagerTest, ReminderEventManager_002, Level1)
879 {
880 auto statusChangeListener
881 = std::make_shared<ReminderEventManager::SystemAbilityStatusChangeListener>(manager);
882 statusChangeListener->OnAddSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, "");
883 statusChangeListener->OnAddSystemAbility(APP_MGR_SERVICE_ID, "");
884 statusChangeListener->OnAddSystemAbility(ABILITY_MGR_SERVICE_ID, "");
885 statusChangeListener->OnAddSystemAbility(-1, "");
886 statusChangeListener->OnRemoveSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, "");
887 statusChangeListener->OnRemoveSystemAbility(APP_MGR_SERVICE_ID, "");
888 statusChangeListener->OnRemoveSystemAbility(ABILITY_MGR_SERVICE_ID, "");
889 statusChangeListener->OnRemoveSystemAbility(-1, "");
890 EXPECT_TRUE(manager != nullptr);
891 }
892
893 /**
894 * @tc.name: ReminderEventManagerTest_005
895 * @tc.desc: Reminder data manager test
896 * @tc.type: FUNC
897 * @tc.require: issueI5YTF3
898 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_005,Level1)899 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_005, Level1)
900 {
901 MatchingSkills customMatchingSkills;
902 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
903 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
904 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
905 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
906 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
907 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CUSTOM_ALERT);
908 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLICK_ALERT);
909 CommonEventSubscribeInfo subscriberInfo(customMatchingSkills);
910 auto subscriber = std::make_shared<ReminderEventManager::ReminderEventCustomSubscriber>(subscriberInfo, manager);
911 EventFwk::CommonEventData data;
912 Want want;
913 want.SetAction(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
914 data.SetWant(want);
915 subscriber->OnReceiveEvent(data);
916 want.SetAction(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
917 data.SetWant(want);
918 subscriber->OnReceiveEvent(data);
919 want.SetAction(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
920 data.SetWant(want);
921 subscriber->OnReceiveEvent(data);
922 want.SetAction(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
923 data.SetWant(want);
924 subscriber->OnReceiveEvent(data);
925 want.SetAction(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
926 data.SetWant(want);
927 subscriber->OnReceiveEvent(data);
928 want.SetAction(ReminderRequest::REMINDER_EVENT_CUSTOM_ALERT);
929 data.SetWant(want);
930 subscriber->OnReceiveEvent(data);
931 want.SetAction(ReminderRequest::REMINDER_EVENT_CLICK_ALERT);
932 data.SetWant(want);
933 subscriber->OnReceiveEvent(data);
934 system("rm -rf /data/service/el1/public/notification/");
935 EXPECT_TRUE(manager != nullptr);
936 }
937
938 /**
939 * @tc.name: ReminderEventManagerTest_006
940 * @tc.desc: Reminder data manager test
941 * @tc.type: FUNC
942 * @tc.require: issueI5YTF3
943 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_006,Level1)944 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_006, Level1)
945 {
946 std::shared_ptr<ReminderDataManager> data;
947 ReminderEventManager::ReminderNotificationSubscriber subscriber(data);
948 subscriber.OnCanceled(nullptr, nullptr, NotificationConstant::PACKAGE_REMOVE_REASON_DELETE);
949 subscriber.OnCanceled(nullptr, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
950 sptr<NotificationRequest> request = new NotificationRequest();
951 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
952 subscriber.OnCanceled(notification, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
953 request->SetAutoDeletedTime(100);
954 subscriber.OnCanceled(notification, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
955 request->SetLabel("REMINDER_AGENT");
956 subscriber.OnCanceled(notification, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
957 EXPECT_TRUE(manager != nullptr);
958 }
959
960 /**
961 * @tc.name: ReminderDataManagerTest_020
962 * @tc.desc: Reminder data manager test
963 * @tc.type: FUNC
964 * @tc.require: issueI5YTF3
965 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_020,Level1)966 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_020, Level1)
967 {
968 sptr<ReminderRequest> reminder = new ReminderRequestTimer(500);
969 manager->CheckNeedNotifyStatus(reminder, ReminderRequest::ActionButtonType::CLOSE);
970 reminder->InitBundleName("test");
971 manager->CheckNeedNotifyStatus(reminder, ReminderRequest::ActionButtonType::CLOSE);
972
973 manager->isReminderAgentReady_ = false;
974 manager->OnUnlockScreen();
975 manager->isReminderAgentReady_ = true;
976 auto queue = manager->queue_;
977 manager->queue_ = nullptr;
978 manager->OnUnlockScreen();
979 manager->queue_ = queue;
980
981 EventFwk::Want want;
982 manager->TerminateAlerting(want);
983 manager->SnoozeReminder(want);
984 manager->ClickReminder(want);
985 manager->SnoozeReminderImpl(reminder);
986 manager->OnLoadReminderEvent();
987 manager->GetFullPath("1p");
988 manager->PlaySoundAndVibration(nullptr);
989 manager->RemoveReminderLocked(500, true);
990 manager->RemoveReminderLocked(500, false);
991 manager->ResetStates(ReminderDataManager::TimerType::ALERTING_TIMER);
992 manager->ResetStates(static_cast<ReminderDataManager::TimerType>(100));
993 manager->StopTimer(static_cast<ReminderDataManager::TimerType>(100));
994 manager->ConnectAppMgr();
995 manager->ConnectAppMgr();
996 manager->OnRemoveAppMgr();
997 Global::Resource::ResourceManager::RawFileDescriptor desc;
998 manager->GetCustomRingFileDesc(reminder, desc);
999 manager->CloseCustomRingFileDesc(500, "");
1000 manager->HandleAutoDeleteReminder(500, 100, 123456);
1001 std::map<std::string, sptr<ReminderRequest>> reminders;
1002 reminders["500"] = reminder;
1003 manager->UpdateShareReminders(reminders);
1004 EXPECT_TRUE(manager != nullptr);
1005 }
1006
1007 /**
1008 * @tc.name: ReminderDataManagerTest_021
1009 * @tc.desc: Reminder data manager test
1010 * @tc.type: FUNC
1011 * @tc.require: issueI5YTF3
1012 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_021,Level1)1013 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_021, Level1)
1014 {
1015 ReminderDataShareHelper::GetInstance().RegisterObserver();
1016 ReminderDataShareHelper::GetInstance().RegisterObserver();
1017 ReminderDataShareHelper::GetInstance().Update(1, 1);
1018 ReminderDataShareHelper::GetInstance().OnDataInsertOrDelete();
1019 ReminderDataShareHelper::GetInstance().OnDataInsertOrDelete();
1020 DataShare::DataShareObserver::ChangeInfo info;
1021 ReminderDataShareHelper::GetInstance().OnDataUpdate(info);
1022 info.valueBuckets_.resize(1);
1023 ReminderDataShareHelper::GetInstance().OnDataUpdate(info);
1024 ReminderDataShareHelper::GetInstance().UnRegisterObserver();
1025 ReminderDataShareHelper::GetInstance().UnRegisterObserver();
1026
1027 ReminderDataShareHelper::ReminderDataObserver observer;
1028 DataShare::DataShareObserver::ChangeInfo info1;
1029 info1.changeType_ = DataShare::DataShareObserver::ChangeType::INSERT;
1030 observer.OnChange(info1);
1031 info1.changeType_ = DataShare::DataShareObserver::ChangeType::UPDATE;
1032 observer.OnChange(info1);
1033 info1.changeType_ = DataShare::DataShareObserver::ChangeType::DELETE;
1034 observer.OnChange(info1);
1035 info1.changeType_ = DataShare::DataShareObserver::ChangeType::OTHER;
1036 observer.OnChange(info1);
1037 EXPECT_TRUE(manager != nullptr);
1038 }
1039
1040 /**
1041 * @tc.name: ReminderDataManagerTest_022
1042 * @tc.desc: Reminder data manager test
1043 * @tc.type: FUNC
1044 * @tc.require: issueI5YTF3
1045 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_022,Level1)1046 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_022, Level1)
1047 {
1048 ReminderConfigChangeObserver observer;
1049 AppExecFwk::Configuration config;
1050 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "");
1051 observer.OnConfigurationUpdated(config);
1052 config.RemoveItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1053 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "test");
1054 observer.languageInfo_ = "test";
1055 observer.OnConfigurationUpdated(config);
1056 observer.languageInfo_ = "1111";
1057 observer.OnConfigurationUpdated(config);
1058 EXPECT_TRUE(manager != nullptr);
1059 }
1060
1061 /**
1062 * @tc.name: ReminderDataManagerTest_023
1063 * @tc.desc: Reminder data manager test
1064 * @tc.type: FUNC
1065 * @tc.require: issueI5YTF3
1066 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_023,Level1)1067 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_023, Level1)
1068 {
1069 sptr<ReminderRequest> reminder = new ReminderRequestTimer(500);
1070 auto buttonWantAgent = std::make_shared<ReminderRequest::ButtonWantAgent>();
1071 auto datashare = std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
1072 reminder->SetActionButton("title", ReminderRequest::ActionButtonType::CLOSE, "resource",
1073 buttonWantAgent, datashare);
1074 manager->IsActionButtonDataShareValid(reminder, 0);
1075 datashare->uri = "1111";
1076 manager->IsActionButtonDataShareValid(reminder, 0);
1077
1078 std::unordered_map<std::string, int32_t> limits;
1079 int32_t totalCount = 0;
1080 reminder->InitUid(1);
1081 reminder->SetTriggerTimeInMilli(100);
1082 manager->CheckShowLimit(limits, totalCount, reminder);
1083 manager->CheckShowLimit(limits, totalCount, reminder);
1084 limits["1_100"] = 100;
1085 manager->CheckShowLimit(limits, totalCount, reminder);
1086 totalCount = 1000;
1087 manager->CheckShowLimit(limits, totalCount, reminder);
1088
1089 sleep(1);
1090 {
1091 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1092 manager->showedReminderVector_.push_back(reminder);
1093 }
1094 manager->HandleAutoDeleteReminder(231, 232, 233);
1095 reminder->InitUid(232);
1096 manager->HandleAutoDeleteReminder(231, 232, 233);
1097 reminder->SetNotificationId(231);
1098 manager->HandleAutoDeleteReminder(231, 232, 233);
1099 reminder->SetAutoDeletedTime(233);
1100 manager->HandleAutoDeleteReminder(231, 232, 233);
1101 {
1102 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1103 manager->showedReminderVector_.clear();
1104 }
1105 EXPECT_TRUE(manager != nullptr);
1106 }
1107
1108 /**
1109 * @tc.name: ReminderDataManagerTest_024
1110 * @tc.desc: Reminder data manager test
1111 * @tc.type: FUNC
1112 * @tc.require: issueI5YTF3
1113 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_024,Level1)1114 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_024, Level1)
1115 {
1116 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1117 timer->SetReminderId(241);
1118 sptr<ReminderRequest> calendar = new ReminderRequestCalendar();
1119 calendar->SetReminderId(242);
1120 {
1121 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1122 manager->reminderVector_.push_back(timer);
1123 manager->reminderVector_.push_back(calendar);
1124 }
1125 std::map<std::string, sptr<ReminderRequest>> reminders;
1126 manager->UpdateShareReminders(reminders);
1127 timer->SetShare(true);
1128 calendar->SetShare(true);
1129 manager->UpdateShareReminders(reminders);
1130 calendar->SetIdentifier("242");
1131 reminders["242"] = calendar;
1132 manager->UpdateShareReminders(reminders);
1133 manager->LoadShareReminders();
1134 {
1135 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1136 manager->reminderVector_.clear();
1137 }
1138 EXPECT_TRUE(manager != nullptr);
1139 }
1140
1141 /**
1142 * @tc.name: ReminderDataManagerTest_025
1143 * @tc.desc: Reminder data manager test
1144 * @tc.type: FUNC
1145 * @tc.require: issueI5YTF3
1146 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_025,Level1)1147 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_025, Level1)
1148 {
1149 DataShare::DataShareObserver::ChangeInfo info;
1150 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1151 info.valueBuckets_.resize(1);
1152
1153 DataShare::DataShareObserver::ChangeInfo::Value alarmTime = static_cast<double>(251);
1154 info.valueBuckets_[0][ReminderCalendarShareTable::ALARM_TIME] = alarmTime;
1155 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1156
1157 DataShare::DataShareObserver::ChangeInfo::Value id = static_cast<double>(252);
1158 info.valueBuckets_[0][ReminderCalendarShareTable::ID] = id;
1159 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1160
1161 DataShare::DataShareObserver::ChangeInfo::Value eventId = static_cast<double>(253);
1162 info.valueBuckets_[0][ReminderCalendarShareTable::EVENT_ID] = eventId;
1163 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1164
1165 DataShare::DataShareObserver::ChangeInfo::Value slotType = static_cast<double>(0);
1166 info.valueBuckets_[0][ReminderCalendarShareTable::SLOT_TYPE] = slotType;
1167 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1168
1169 DataShare::DataShareObserver::ChangeInfo::Value title = std::string("25");
1170 info.valueBuckets_[0][ReminderCalendarShareTable::TITLE] = title;
1171 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1172
1173 DataShare::DataShareObserver::ChangeInfo::Value content = std::string("255");
1174 info.valueBuckets_[0][ReminderCalendarShareTable::CONTENT] = content;
1175 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1176
1177 DataShare::DataShareObserver::ChangeInfo::Value buttons = std::string("");
1178 info.valueBuckets_[0][ReminderCalendarShareTable::BUTTONS] = buttons;
1179 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1180
1181 DataShare::DataShareObserver::ChangeInfo::Value wantAgent = std::string("");
1182 info.valueBuckets_[0][ReminderCalendarShareTable::WANT_AGENT] = wantAgent;
1183 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1184
1185 DataShare::DataShareObserver::ChangeInfo::Value identifier = std::string("256");
1186 info.valueBuckets_[0][ReminderCalendarShareTable::IDENTIFIER] = identifier;
1187 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1188
1189 DataShare::DataShareObserver::ChangeInfo::Value ends = static_cast<double>(1737948039000);
1190 info.valueBuckets_[0][ReminderCalendarShareTable::END] = ends;
1191 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1192 EXPECT_TRUE(manager != nullptr);
1193 }
1194
1195 /**
1196 * @tc.name: ReminderDataManagerTest_026
1197 * @tc.desc: Reminder data manager test
1198 * @tc.type: FUNC
1199 * @tc.require: issueI5YTF3
1200 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_026,Level1)1201 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_026, Level1)
1202 {
1203 ReminderTimerInfo info;
1204 info.OnTrigger();
1205 info.SetReminderTimerType(ReminderTimerInfo::ReminderTimerType::REMINDER_TIMER_LOAD);
1206 info.OnTrigger();
1207 info.SetReminderTimerType(static_cast<ReminderTimerInfo::ReminderTimerType>(9));
1208 info.OnTrigger();
1209 EXPECT_TRUE(manager != nullptr);
1210 }
1211
1212 /**
1213 * @tc.name: ReminderDataManagerTest_027
1214 * @tc.desc: Reminder data manager test
1215 * @tc.type: FUNC
1216 * @tc.require: issueI5YTF3
1217 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_027,Level1)1218 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_027, Level1)
1219 {
1220 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1221 timer->SetReminderId(271);
1222 auto wantInfo = timer->wantAgentInfo_;
1223 timer->wantAgentInfo_ = nullptr;
1224 {
1225 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1226 manager->reminderVector_.push_back(timer);
1227 }
1228 EventFwk::Want want;
1229 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 271);
1230 manager->ClickReminder(want);
1231 {
1232 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1233 manager->reminderVector_.clear();
1234 manager->reminderVector_.push_back(timer);
1235 }
1236 timer->wantAgentInfo_ = wantInfo;
1237 manager->ClickReminder(want);
1238 {
1239 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1240 manager->reminderVector_.clear();
1241 manager->reminderVector_.push_back(timer);
1242 }
1243 timer->wantAgentInfo_->pkgName = "test";
1244 manager->ClickReminder(want);
1245 {
1246 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1247 manager->reminderVector_.clear();
1248 manager->reminderVector_.push_back(timer);
1249 }
1250 timer->SetSystemApp(true);
1251 manager->HandleCustomButtonClick(want);
1252 {
1253 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1254 manager->reminderVector_.clear();
1255 }
1256 EXPECT_TRUE(manager != nullptr);
1257 }
1258
1259 /**
1260 * @tc.name: ReminderDataManagerTest_028
1261 * @tc.desc: Reminder data manager test
1262 * @tc.type: FUNC
1263 * @tc.require: issueI5YTF3
1264 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_028,Level1)1265 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_028, Level1)
1266 {
1267 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1268 timer->SetReminderId(281);
1269 sptr<ReminderRequest> timer2 = new ReminderRequestTimer(500);
1270 timer2->SetReminderId(282);
1271 {
1272 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1273 manager->showedReminderVector_.push_back(timer);
1274 manager->showedReminderVector_.push_back(timer2);
1275 }
1276 manager->RemoveFromShowedReminders(timer);
1277 {
1278 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1279 manager->showedReminderVector_.clear();
1280 }
1281 EXPECT_TRUE(manager != nullptr);
1282 }
1283
1284 /**
1285 * @tc.name: ReminderDataManagerTest_029
1286 * @tc.desc: Reminder data manager test
1287 * @tc.type: FUNC
1288 * @tc.require: issueI5YTF3
1289 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_029,Level1)1290 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_029, Level1)
1291 {
1292 manager->InitShareReminders(true);
1293 manager->InitShareReminders(false);
1294 manager->isReminderAgentReady_ = false;
1295 manager->OnUserSwitch(1);
1296 sleep(1);
1297 manager->isReminderAgentReady_ = true;
1298 auto queue = std::move(manager->queue_);
1299 manager->OnUserSwitch(1);
1300 sleep(1);
1301 manager->queue_ = std::move(queue);
1302 manager->OnUserSwitch(1);
1303 EXPECT_TRUE(manager != nullptr);
1304 sleep(1);
1305 }
1306 } // namespace Notification
1307 } // namespace OHOS
1308