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 #include "reminder_utils.h"
38
39 using namespace testing::ext;
40 using namespace OHOS::EventFwk;
41 namespace OHOS {
42 namespace Notification {
43 class ReminderDataManagerTest : public testing::Test {
44 public:
SetUpTestCase()45 static void SetUpTestCase()
46 {
47 ReminderDataManager::InitInstance();
48 manager = ReminderDataManager::GetInstance();
49 manager->RegisterConfigurationObserver();
50 manager->Init();
51 }
TearDownTestCase()52 static void TearDownTestCase()
53 {
54 manager->showedReminderVector_.clear();
55 manager = nullptr;
56 }
SetUp()57 void SetUp() {};
TearDown()58 void TearDown() {};
59
60 public:
61 static std::shared_ptr<ReminderDataManager> manager;
62 };
63
64 std::shared_ptr<ReminderDataManager> ReminderDataManagerTest::manager = nullptr;
65
66 /**
67 * @tc.name: GetVaildReminders_00001
68 * @tc.desc: Reminder data manager test
69 * @tc.type: FUNC
70 * @tc.require: issue#I9IIDE
71 */
HWTEST_F(ReminderDataManagerTest,GetVaildReminders_00001,Level1)72 HWTEST_F(ReminderDataManagerTest, GetVaildReminders_00001, Level1)
73 {
74 IPCSkeleton::SetCallingTokenID(100);
75 manager->store_->Init();
76 int32_t callingUid = 98765;
77 sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(static_cast<uint64_t>(50));
78 reminder1->InitCreatorBundleName("test_getvalid");
79 reminder1->InitCreatorUid(callingUid);
80 reminder1->InitBundleName("test_getvalid");
81 reminder1->InitUid(callingUid);
82 reminder1->SetExpired(false);
83 manager->PublishReminder(reminder1, callingUid);
84
85 sptr<ReminderRequest> reminder2 = new ReminderRequestTimer(51);
86 reminder2->InitCreatorBundleName("test_getvalid");
87 reminder2->InitCreatorUid(callingUid);
88 reminder2->InitBundleName("test_getvalid");
89 reminder2->InitUid(callingUid);
90 reminder2->SetExpired(true);
91 manager->PublishReminder(reminder2, callingUid);
92
93 std::vector<ReminderRequestAdaptation> reminders;
94 manager->GetValidReminders(callingUid, reminders);
95 EXPECT_TRUE(reminders.size() >= 0);
96 }
97
98 /**
99 * @tc.name: CancelReminderToDb_0001
100 * @tc.desc: Reminder data manager test
101 * @tc.type: FUNC
102 * @tc.require: issue#I9IIDE
103 */
HWTEST_F(ReminderDataManagerTest,CancelReminderToDb_0001,Level1)104 HWTEST_F(ReminderDataManagerTest, CancelReminderToDb_0001, Level1)
105 {
106 IPCSkeleton::SetCallingTokenID(100);
107 int32_t callingUid = 99999;
108 sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(static_cast<uint64_t>(500));
109 reminder1->InitCreatorBundleName("test_getvalid");
110 reminder1->InitCreatorUid(callingUid);
111 reminder1->InitBundleName("test_getvalid");
112 reminder1->InitUid(callingUid);
113 reminder1->SetExpired(false);
114 manager->PublishReminder(reminder1, callingUid);
115
116 auto store = std::move(manager->store_);
117 int32_t ret = manager->CancelReminderToDb(reminder1->GetReminderId(), callingUid);
118 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
119 manager->store_ = std::move(store);
120
121 ret = manager->CancelReminderToDb(12457, callingUid);
122 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
123 ret = manager->CancelReminderToDb(reminder1->GetReminderId(), callingUid);
124 EXPECT_TRUE(ret == ERR_OK);
125 }
126
127 /**
128 * @tc.name: ReminderDataManagerTest_001
129 * @tc.desc: Reminder data manager test
130 * @tc.type: FUNC
131 * @tc.require: issueI5YTF3
132 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_001,Level1)133 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_001, Level1)
134 {
135 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
136 int32_t reminderId = -1;
137 manager->PublishReminder(reminder, reminderId);
138 manager->CancelReminder(reminderId, -1);
139 manager->CancelAllReminders("", -1, -1);
140 manager->CancelAllReminders(-1);
141 manager->IsMatched(reminder, -1, -1, true);
142 remove("/data/service/el1/public/notification/notification.db");
143 EXPECT_TRUE(manager != nullptr);
144 }
145
146 /**
147 * @tc.name: ReminderDataManagerTest_002
148 * @tc.desc: Reminder data manager test
149 * @tc.type: FUNC
150 * @tc.require: issueI5YTF3
151 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_002,Level1)152 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_002, Level1)
153 {
154 int32_t callingUid = -1;
155 std::vector<ReminderRequestAdaptation> vec;
156 manager->GetValidReminders(callingUid, vec);
157 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
158
159 manager->CheckReminderLimitExceededLocked(callingUid, reminder);
160 manager->CancelNotification(reminder);
161 reminder->SetReminderId(10);
162 manager->AddToShowedReminders(reminder);
163 manager->AddToShowedReminders(reminder);
164 remove("/data/service/el1/public/notification/notification.db");
165 EXPECT_TRUE(manager != nullptr);
166 }
167
168 /**
169 * @tc.name: ReminderDataManagerTest_003
170 * @tc.desc: Reminder data manager test
171 * @tc.type: FUNC
172 * @tc.require: issueI5YTF3
173 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_003,Level1)174 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_003, Level1)
175 {
176 manager->isReminderAgentReady_ = false;
177 manager->alertingReminderId_ = -1;
178 manager->OnUserSwitch(0);
179 manager->OnUserRemove(0);
180 manager->alertingReminderId_ = 1;
181 manager->OnUserSwitch(0);
182 manager->isReminderAgentReady_ = true;
183 manager->OnUserSwitch(0);
184 manager->alertingReminderId_ = -1;
185 manager->OnUserSwitch(0);
186 manager->OnUserRemove(0);
187 manager->OnBundleMgrServiceStart();
188 manager->OnAbilityMgrServiceStart();
189 remove("/data/service/el1/public/notification/notification.db");
190 EXPECT_TRUE(manager != nullptr);
191 }
192
193 /**
194 * @tc.name: ReminderDataManagerTest_004
195 * @tc.desc: Reminder data manager test
196 * @tc.type: FUNC
197 * @tc.require: issueI5YTF3
198 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_004,Level1)199 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_004, Level1)
200 {
201 manager->showedReminderVector_.clear();
202 int32_t callingUid = -1;
203 manager->OnProcessDiedLocked(callingUid);
204 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
205 manager->CreateTimerInfo(ReminderDataManager::TimerType::TRIGGER_TIMER, reminder);
206 manager->CreateTimerInfo(ReminderDataManager::TimerType::ALERTING_TIMER, reminder);
207 manager->FindReminderRequestLocked(0, false);
208 reminder->SetReminderId(10);
209 manager->reminderVector_.push_back(reminder);
210 manager->FindReminderRequestLocked(10, false);
211 manager->FindReminderRequestLocked(10, false);
212 manager->FindReminderRequestLocked(10, false);
213 remove("/data/service/el1/public/notification/notification.db");
214 EXPECT_TRUE(manager != nullptr);
215 }
216
217 /**
218 * @tc.name: ReminderDataManagerTest_005
219 * @tc.desc: Reminder data manager test
220 * @tc.type: FUNC
221 * @tc.require: issueI5YTF3
222 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_005,Level1)223 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_005, Level1)
224 {
225 EventFwk::Want want;
226 manager->CloseReminder(want, true);
227 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
228 reminder->SetReminderId(1);
229 manager->activeReminderId_ = 1;
230 manager->activeReminder_ = reminder;
231 manager->CloseReminder(reminder, true);
232 reminder->SetReminderId(2);
233 manager->alertingReminderId_ = 2;
234 manager->CloseReminder(reminder, true);
235 reminder->SetReminderId(3);
236 manager->CloseReminder(reminder, true);
237 manager->CloseReminder(reminder, false);
238 reminder->SetReminderId(4);
239 reminder->SetGroupId("");
240 manager->CloseReminder(reminder, true);
241 remove("/data/service/el1/public/notification/notification.db");
242 EXPECT_TRUE(manager != nullptr);
243 }
244
245 /**
246 * @tc.name: ReminderDataManagerTest_006
247 * @tc.desc: Reminder data manager test
248 * @tc.type: FUNC
249 * @tc.require: issueI5YTF3
250 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_006,Level1)251 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_006, Level1)
252 {
253 manager->RefreshRemindersDueToSysTimeChange(0);
254 manager->RefreshRemindersDueToSysTimeChange(1);
255 manager->activeReminderId_ = 1;
256 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
257 manager->activeReminder_ = reminder;
258 manager->RefreshRemindersDueToSysTimeChange(1);
259 remove("/data/service/el1/public/notification/notification.db");
260 EXPECT_TRUE(manager != nullptr);
261 }
262
263 /**
264 * @tc.name: ReminderDataManagerTest_007
265 * @tc.desc: Reminder data manager test
266 * @tc.type: FUNC
267 * @tc.require: issueI5YTF3
268 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_007,Level1)269 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_007, Level1)
270 {
271 EventFwk::Want want;
272 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
273 manager->ShowActiveReminder(want);
274 manager->CloseReminder(want, true);
275 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
276 reminder->SetReminderId(10);
277 manager->reminderVector_.push_back(reminder);
278 manager->ShowActiveReminder(want);
279 manager->activeReminderId_ = 10;
280 manager->activeReminder_ = reminder;
281 manager->ShowActiveReminder(want);
282 manager->CloseReminder(want, false);
283 remove("/data/service/el1/public/notification/notification.db");
284 EXPECT_TRUE(manager != nullptr);
285 }
286
287 /**
288 * @tc.name: ReminderDataManagerTest_008
289 * @tc.desc: Reminder data manager test
290 * @tc.type: FUNC
291 * @tc.require: issueI5YTF3
292 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_008,Level1)293 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_008, Level1)
294 {
295 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
296 manager->TerminateAlerting(0, reminder);
297 manager->TerminateAlerting(nullptr, "");
298 manager->TerminateAlerting(reminder, "");
299 reminder->state_ = 2;
300 manager->TerminateAlerting(reminder, "");
301 remove("/data/service/el1/public/notification/notification.db");
302 EXPECT_TRUE(manager != nullptr);
303 }
304
305 /**
306 * @tc.name: ReminderDataManagerTest_009
307 * @tc.desc: Reminder data manager test
308 * @tc.type: FUNC
309 * @tc.require: issueI5YTF3
310 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_009,Level1)311 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_009, Level1)
312 {
313 int32_t callingUid = -1;
314 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
315 manager->UpdateAndSaveReminderLocked(reminder);
316 sptr<ReminderAgentService> service(new ReminderAgentService);
317 manager->ShouldAlert(nullptr);
318 manager->currentUserId_ = 0;
319 manager->ShouldAlert(reminder);
320 remove("/data/service/el1/public/notification/notification.db");
321 EXPECT_TRUE(manager != nullptr);
322 }
323
324 /**
325 * @tc.name: ReminderDataManagerTest_010
326 * @tc.desc: Reminder data manager test
327 * @tc.type: FUNC
328 * @tc.require: issueI5YTF3
329 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_010,Level1)330 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_010, Level1)
331 {
332 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
333 manager->HandleSysTimeChange(reminder);
334 manager->SetActiveReminder(nullptr);
335 manager->SetActiveReminder(reminder);
336 manager->SetAlertingReminder(nullptr);
337 manager->SetAlertingReminder(reminder);
338 remove("/data/service/el1/public/notification/notification.db");
339 EXPECT_TRUE(manager != nullptr);
340 }
341
342 /**
343 * @tc.name: ReminderDataManagerTest_011
344 * @tc.desc: Reminder data manager test
345 * @tc.type: FUNC
346 * @tc.require: issueI5YTF3
347 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_011,Level1)348 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_011, Level1)
349 {
350 sptr<ReminderRequest> reminder(new ReminderRequestTimer(10));
351 reminder->SetReminderId(0);
352 manager->ShowReminder(reminder, true, true, true, true, true);
353 reminder->SetReminderId(10);
354 manager->ShowReminder(reminder, true, true, true, true, true);
355 manager->ShowReminder(reminder, true, true, true, true, true);
356 manager->alertingReminderId_ = 1;
357 manager->ShowReminder(reminder, true, true, true, true, true);
358 manager->alertingReminderId_ = -1;
359 manager->ShowReminder(reminder, true, true, true, true, true);
360 remove("/data/service/el1/public/notification/notification.db");
361 EXPECT_TRUE(manager != nullptr);
362 }
363
364 /**
365 * @tc.name: ReminderDataManagerTest_012
366 * @tc.desc: Reminder data manager test
367 * @tc.type: FUNC
368 * @tc.require: issueI5YTF3
369 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_012,Level1)370 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_012, Level1)
371 {
372 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
373 manager->activeReminderId_ = 10;
374 manager->activeReminder_ = reminder;
375 reminder->SetReminderId(10);
376 manager->activeReminderId_ = 1;
377 remove("/data/service/el1/public/notification/notification.db");
378 EXPECT_TRUE(manager != nullptr);
379 }
380
381 /**
382 * @tc.name: ReminderDataManagerTest_013
383 * @tc.desc: Reminder data manager test
384 * @tc.type: FUNC
385 * @tc.require: issueI5YTF3
386 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_013,Level1)387 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_013, Level1)
388 {
389 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
390 manager->activeReminderId_ = 10;
391 manager->activeReminder_ = reminder;
392 reminder->SetReminderId(10);
393 remove("/data/service/el1/public/notification/notification.db");
394 EXPECT_TRUE(manager != nullptr);
395 }
396
397 /**
398 * @tc.name: ReminderDataManagerTest_014
399 * @tc.desc: Reminder data manager test
400 * @tc.type: FUNC
401 * @tc.require: issueI5YTF3
402 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_014,Level1)403 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_014, Level1)
404 {
405 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
406 reminder->SetReminderId(0);
407 manager->StartRecentReminder();
408 manager->StopAlertingReminder(nullptr);
409 manager->alertingReminderId_ = -1;
410 manager->StopAlertingReminder(reminder);
411 manager->alertingReminderId_ = 1;
412 manager->StopAlertingReminder(reminder);
413 reminder->SetReminderId(1);
414 manager->StopAlertingReminder(reminder);
415 manager->Dump();
416 remove("/data/service/el1/public/notification/notification.db");
417 EXPECT_TRUE(manager != nullptr);
418 }
419
420 /**
421 * @tc.name: ReminderDataManagerTest_015
422 * @tc.desc: Reminder data manager test
423 * @tc.type: FUNC
424 * @tc.require: issueI5YTF3
425 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_015,Level1)426 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_015, Level1)
427 {
428 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
429 std::vector<sptr<ReminderRequest>> vec;
430 vec.push_back(reminder);
431 manager->HandleImmediatelyShow(vec, true);
432 manager->HandleRefreshReminder(0, reminder);
433 manager->HandleSameNotificationIdShowing(reminder);
434 manager->Init();
435 manager->InitUserId();
436 manager->IsAllowedNotify(reminder);
437 manager->IsAllowedNotify(nullptr);
438 manager->IsReminderAgentReady();
439 remove("/data/service/el1/public/notification/notification.db");
440 EXPECT_TRUE(manager != nullptr);
441 }
442
443 /**
444 * @tc.name: ReminderDataManagerTest_016
445 * @tc.desc: Reminder data manager test
446 * @tc.type: FUNC
447 * @tc.require: issuesI8CAQB
448 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_016,Level1)449 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_016, Level1)
450 {
451 // not SystemApp
452 std::vector<uint8_t> daysOfWeek;
453 sptr<ReminderRequest> reminder = new ReminderRequestAlarm(0, 1, daysOfWeek);
454 std::shared_ptr<ReminderRequest::ButtonWantAgent> buttonWantAgent =
455 std::make_shared<ReminderRequest::ButtonWantAgent>();
456 std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> buttonDataShareUpdate =
457 std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
458 reminder->SetSystemApp(false);
459 reminder->SetActionButton("不再提醒", ReminderRequest::ActionButtonType::CLOSE,
460 "", buttonWantAgent, buttonDataShareUpdate);
461 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::CLOSE);
462
463 // INVALID ActionButtonType
464 reminder->SetSystemApp(true);
465 reminder->SetActionButton("无效的", ReminderRequest::ActionButtonType::INVALID,
466 "", buttonWantAgent, buttonDataShareUpdate);
467 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::INVALID);
468
469 // actionButtonType does not exist
470 std::map<ReminderRequest::ActionButtonType, ReminderRequest::ActionButtonInfo> actionButtonMap;
471 manager->CheckUpdateConditions(reminder, ReminderRequest::ActionButtonType::CLOSE, actionButtonMap);
472
473 // null ButtonDataShareUpdate
474 reminder->SetActionButton("稍后提醒", ReminderRequest::ActionButtonType::SNOOZE, "", buttonWantAgent);
475 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::SNOOZE);
476
477 // not have uri
478 manager->UpdateAppDatabase(reminder, ReminderRequest::ActionButtonType::CLOSE);
479
480 // update datashare
481 sptr<ReminderRequest> reminder1 = new ReminderRequestAlarm(2, 3, daysOfWeek);
482 std::shared_ptr<ReminderRequest::ButtonWantAgent> buttonWantAgent1 =
483 std::make_shared<ReminderRequest::ButtonWantAgent>();
484 std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> buttonDataShareUpdate1 =
485 std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
486 reminder1->SetSystemApp(true);
487 reminder1->InitUserId(100);
488 buttonDataShareUpdate1->uri = "datashareTest://com.acts.dataShareTest";
489 buttonDataShareUpdate1->equalTo = "name<SEP:/>string<SEP:/>li<SEP;/>"
490 "id<SEP:/>double<SEP:/>3.0<SEP;/>status<SEP:/>bool<SEP:/>true";
491 buttonDataShareUpdate1->valuesBucket = "name<SEP:/>string<SEP:/>wang<SEP;/>"
492 "id<SEP:/>double<SEP:/>4.0<SEP;/>status<SEP:/>bool<SEP:/>true<SEP;/>actionId<SEP:/>null<SEP:/>null";
493 reminder1->SetActionButton("不再提醒", ReminderRequest::ActionButtonType::CLOSE, "",
494 buttonWantAgent1, buttonDataShareUpdate1);
495 manager->UpdateAppDatabase(reminder1, ReminderRequest::ActionButtonType::CLOSE);
496 EXPECT_TRUE(reminder1->actionButtonMap_.size() > 0);
497 }
498
499 /**
500 * @tc.name: ReminderDataManagerTest_017
501 * @tc.desc: Reminder data manager test
502 * @tc.type: FUNC
503 * @tc.require: issueI8CDH3
504 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_017,Level1)505 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_017, Level1)
506 {
507 IPCSkeleton::SetCallingTokenID(1);
508 sptr<ReminderRequest> reminder1 = new ReminderRequestTimer(10);
509 sptr<ReminderRequest> reminder2 = new ReminderRequestTimer(10);
510 sptr<ReminderRequest> reminder3 = new ReminderRequestTimer(10);
511 int32_t callingUid = 1;
512 reminder1->SetReminderId(1);
513 reminder2->SetReminderId(2);
514 reminder3->SetReminderId(3);
515 reminder1->SetGroupId("123");
516 reminder2->SetGroupId("123");
517 reminder3->SetGroupId("124");
518 manager->PublishReminder(reminder1, callingUid);
519 manager->PublishReminder(reminder2, callingUid);
520 manager->PublishReminder(reminder3, callingUid);
521 manager->CloseRemindersByGroupId(1, "test", "123");
522 remove("/data/service/el1/public/notification/notification.db");
523 EXPECT_TRUE(reminder2->isExpired_);
524 }
525
526 /**
527 * @tc.name: ReminderDataManagerTest_018
528 * @tc.desc: Reminder data manager test
529 * @tc.type: FUNC
530 * @tc.require: issueI8E7Z1
531 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_018,Level1)532 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_018, Level1)
533 {
534 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
535 std::string ringUri = "123";
536 reminder->SetCustomRingUri(ringUri);
537 std::string getRingUri = reminder->GetCustomRingUri();
538 ASSERT_EQ(ringUri, getRingUri);
539 }
540
541 /**
542 * @tc.name: ReminderEventManagerTest_001
543 * @tc.desc: Reminder data manager test
544 * @tc.type: FUNC
545 * @tc.require: issueI5YTF3
546 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_001,Level1)547 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_001, Level1)
548 {
549 MatchingSkills matchingSkills;
550 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
551 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
552 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
553 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
554 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
555 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
556 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
557 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
558 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
559 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
560 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
561 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
562 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
563 auto subscriber = std::make_shared<ReminderEventManager::ReminderEventSubscriber>(subscriberInfo, manager);
564 EventFwk::CommonEventData data;
565 Want want;
566 want.SetAction(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
567 data.SetWant(want);
568 subscriber->OnReceiveEvent(data);
569 want.SetAction(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
570 data.SetWant(want);
571 subscriber->OnReceiveEvent(data);
572 want.SetAction(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
573 data.SetWant(want);
574 subscriber->OnReceiveEvent(data);
575 want.SetAction(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
576 data.SetWant(want);
577 subscriber->OnReceiveEvent(data);
578 want.SetAction(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
579 data.SetWant(want);
580 subscriber->OnReceiveEvent(data);
581 want.SetAction(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
582 data.SetWant(want);
583 subscriber->OnReceiveEvent(data);
584 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
585 data.SetWant(want);
586 subscriber->OnReceiveEvent(data);
587 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
588 data.SetWant(want);
589 subscriber->OnReceiveEvent(data);
590 want.SetAction(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
591 data.SetWant(want);
592 subscriber->OnReceiveEvent(data);
593 want.SetAction(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
594 data.SetWant(want);
595 subscriber->OnReceiveEvent(data);
596 want.SetAction(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
597 data.SetWant(want);
598 subscriber->OnReceiveEvent(data);
599 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
600 data.SetWant(want);
601 subscriber->OnReceiveEvent(data);
602 want.SetAction(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
603 data.SetWant(want);
604 subscriber->OnReceiveEvent(data);
605 remove("/data/service/el1/public/notification/notification.db");
606 EXPECT_TRUE(manager != nullptr);
607 }
608
609 /**
610 * @tc.name: ReminderEventManagerTest_002
611 * @tc.desc: Reminder data manager test
612 * @tc.type: FUNC
613 * @tc.require: issueI5YTF3
614 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_002,Level1)615 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_002, Level1)
616 {
617 auto statusChangeListener
618 = std::make_shared<ReminderEventManager::SystemAbilityStatusChangeListener>(manager);
619 statusChangeListener->OnAddSystemAbility(0, "");
620 statusChangeListener->OnRemoveSystemAbility(0, "");
621 remove("/data/service/el1/public/notification/notification.db");
622 EXPECT_TRUE(manager != nullptr);
623 }
624
625 /**
626 * @tc.name: ReminderEventManagerTest_003
627 * @tc.desc: Reminder data manager test
628 * @tc.type: FUNC
629 * @tc.require: issueI5YTF3
630 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_003,Level1)631 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_003, Level1)
632 {
633 auto timeInfo = std::make_shared<ReminderTimerInfo>();
634 timeInfo->SetType(0);
635 timeInfo->SetRepeat(false);
636 timeInfo->SetInterval(0);
637 timeInfo->SetWantAgent(nullptr);
638 timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALARM_ALERT;
639 timeInfo->OnTrigger();
640 timeInfo->action_ = ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT;
641 timeInfo->OnTrigger();
642 remove("/data/service/el1/public/notification/notification.db");
643 EXPECT_TRUE(manager != nullptr);
644 }
645
646 /**
647 * @tc.name: ReminderEventManagerTest_004
648 * @tc.desc: Reminder data manager test
649 * @tc.type: FUNC
650 * @tc.require: issueI5YTF3
651 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_004,Level1)652 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_004, Level1)
653 {
654 EventFwk::Want want;
655 manager->HandleCustomButtonClick(want);
656 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
657 manager->reminderVector_.push_back(reminder);
658 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 10);
659 manager->HandleCustomButtonClick(want);
660 remove("/data/service/el1/public/notification/notification.db");
661 EXPECT_TRUE(manager != nullptr);
662 }
663
664 /**
665 * @tc.name: StartExtensionAbilityTest_001
666 * @tc.desc: Reminder data manager test
667 * @tc.type: FUNC
668 * @tc.require: issueI92G9T
669 */
HWTEST_F(ReminderDataManagerTest,StartExtensionAbilityTest_001,Level1)670 HWTEST_F(ReminderDataManagerTest, StartExtensionAbilityTest_001, Level1)
671 {
672 auto reminder1 = new ReminderRequestCalendar(10);
673 bool ret1 = manager->StartExtensionAbility(reminder1, 0);
674 EXPECT_TRUE(ret1);
675
676 auto reminder2 = new ReminderRequestCalendar(10);
677 auto wantInfo = std::make_shared<ReminderRequest::WantAgentInfo>();
678 reminder2->SetRRuleWantAgentInfo(wantInfo);
679 bool ret2 = manager->StartExtensionAbility(reminder2, 0);
680 EXPECT_TRUE(ret2);
681 }
682
683 /**
684 * @tc.name: IsBelongToSameAppTest_001
685 * @tc.desc: Reminder data manager test
686 * @tc.type: FUNC
687 * @tc.require: issue#I97Q9Q
688 */
HWTEST_F(ReminderDataManagerTest,IsBelongToSameAppTest_001,Level1)689 HWTEST_F(ReminderDataManagerTest, IsBelongToSameAppTest_001, Level1)
690 {
691 int32_t uidSrc = 100;
692 int32_t uidTar = 100;
693 EXPECT_TRUE(manager->IsBelongToSameApp(uidSrc, uidTar));
694
695 uidTar = 101;
696 EXPECT_FALSE(manager->IsBelongToSameApp(uidSrc, uidTar));
697 }
698
699 /**
700 * @tc.name: CheckIsSameAppTest_001
701 * @tc.desc: Reminder data manager test
702 * @tc.type: FUNC
703 * @tc.require: issue#I97Q9Q
704 */
HWTEST_F(ReminderDataManagerTest,CheckIsSameAppTest_001,Level1)705 HWTEST_F(ReminderDataManagerTest, CheckIsSameAppTest_001, Level1)
706 {
707 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
708 reminder->InitCreatorBundleName("test");
709 int32_t callingUid = 100;
710 reminder->InitCreatorUid(callingUid);
711 EXPECT_TRUE(manager->CheckIsSameApp(reminder, callingUid));
712
713 reminder->InitCreatorUid(-1);
714 EXPECT_FALSE(manager->CheckIsSameApp(reminder, callingUid));
715 }
716
717 /**
718 * @tc.name: CheckPulishReminder
719 * @tc.desc: Reminder data manager test
720 * @tc.type: FUNC
721 * @tc.require: issue#I97Q9Q
722 */
HWTEST_F(ReminderDataManagerTest,CheckPulishReminder_0001,Level1)723 HWTEST_F(ReminderDataManagerTest, CheckPulishReminder_0001, Level1)
724 {
725 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
726 int32_t callingUid = -1;
727 IPCSkeleton::SetCallingTokenID(0);
728 ErrCode ret = manager->PublishReminder(reminder, callingUid);
729 ASSERT_EQ(ret, ERR_REMINDER_CALLER_TOKEN_INVALID);
730
731 IPCSkeleton::SetCallingTokenID(1);
732 ret = manager->PublishReminder(reminder, callingUid);
733 EXPECT_NE(ret, ERR_REMINDER_DATA_SHARE_PERMISSION_DENIED);
734 }
735
736 /**
737 * @tc.name: OnLanguageChanged
738 * @tc.desc: Reminder data manager test
739 * @tc.type: FUNC
740 * @tc.require: issue#I97Q9Q
741 */
HWTEST_F(ReminderDataManagerTest,OnLanguageChanged_0001,Level1)742 HWTEST_F(ReminderDataManagerTest, OnLanguageChanged_0001, Level1)
743 {
744 sptr<ReminderRequest> reminder = new ReminderRequestTimer(10);
745 reminder->SetReminderId(10);
746 std::string title = "this is title";
747 std::string resource = "close";
748 ReminderRequest::ActionButtonType type = ReminderRequest::ActionButtonType::CLOSE;
749 reminder->SetActionButton(title, type, resource);
750
751 manager->reminderVector_.push_back(reminder);
752 manager->showedReminderVector_.push_back(reminder);
753
754 manager->OnLanguageChanged();
755 EXPECT_TRUE(reminder->actionButtonMap_[type].title == "this is title");
756 }
757
758 /**
759 * @tc.name: ExcludeDate
760 * @tc.desc: Reminder data manager test
761 * @tc.type: FUNC
762 * @tc.require: issue#I97Q9Q
763 */
HWTEST_F(ReminderDataManagerTest,ExcludeDate_0001,Level1)764 HWTEST_F(ReminderDataManagerTest, ExcludeDate_0001, Level1)
765 {
766 std::vector<int64_t> dates;
767 int32_t callingUid = -1;
768 auto result = manager->CheckExcludeDateParam(9999, callingUid);
769 EXPECT_TRUE(result == nullptr);
770
771 auto ret = manager->AddExcludeDate(9999, 100, callingUid);
772 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
773
774 ret = manager->DelExcludeDates(9999, callingUid);
775 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
776
777 ret = manager->GetExcludeDates(9999, callingUid, dates);
778 EXPECT_TRUE(ret == ERR_REMINDER_NOT_EXIST);
779
780 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(10);
781 reminder->InitCreatorBundleName("test1");
782 reminder->InitUserId(-1);
783 reminder->reminderId_ = 100;
784 manager->reminderVector_.push_back(reminder);
785 result = manager->CheckExcludeDateParam(100, callingUid);
786 EXPECT_TRUE(result == nullptr);
787
788 reminder->InitCreatorBundleName("test");
789 reminder->reminderType_ = ReminderRequest::ReminderType::TIMER;
790 result = manager->CheckExcludeDateParam(100, callingUid);
791 EXPECT_TRUE(result == nullptr);
792
793 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
794 result = manager->CheckExcludeDateParam(100, callingUid);
795 EXPECT_TRUE(result == nullptr);
796
797 reminder->repeatDaysOfWeek_ = 1;
798 result = manager->CheckExcludeDateParam(100, callingUid);
799 EXPECT_TRUE(result != nullptr);
800
801 ret = manager->AddExcludeDate(100, 100, callingUid);
802 EXPECT_TRUE(ret == ERR_OK);
803
804 ret = manager->DelExcludeDates(100, callingUid);
805 EXPECT_TRUE(ret == ERR_OK);
806
807 ret = manager->GetExcludeDates(100, callingUid, dates);
808 EXPECT_TRUE(ret == ERR_OK);
809 }
810
811 /**
812 * @tc.name: InitStartExtensionAbility
813 * @tc.desc: Reminder data manager test
814 * @tc.type: FUNC
815 * @tc.require: issue#I9IIDE
816 */
HWTEST_F(ReminderDataManagerTest,InitStartExtensionAbility_0001,Level1)817 HWTEST_F(ReminderDataManagerTest, InitStartExtensionAbility_0001, Level1)
818 {
819 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(10);
820 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
821 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
822 uint64_t now = calendar->GetNowInstantMilli();
823 calendar->SetDateTime(now-50000);
824 calendar->SetEndDateTime(now+50000);
825 manager->reminderVector_.push_back(calendar);
826 manager->Init();
827 EXPECT_TRUE(!manager->reminderVector_.empty());
828 }
829
830 /**
831 * @tc.name: CancelAllReminders_00001
832 * @tc.desc: Reminder data manager test
833 * @tc.type: FUNC
834 * @tc.require: issue#I9IIDE
835 */
HWTEST_F(ReminderDataManagerTest,CancelAllReminders_00001,Level1)836 HWTEST_F(ReminderDataManagerTest, CancelAllReminders_00001, Level1)
837 {
838 int32_t ret = manager->CancelAllReminders("", -1, -1);
839 EXPECT_TRUE(ret == ERR_OK);
840
841 ret = manager->CancelAllReminders("", 100, 20020152);
842 EXPECT_TRUE(ret == ERR_OK);
843 }
844
845 /**
846 * @tc.name: IsMatched_00001
847 * @tc.desc: Reminder data manager test
848 * @tc.type: FUNC
849 * @tc.require: issue#I9IIDE
850 */
HWTEST_F(ReminderDataManagerTest,IsMatched_00001,Level1)851 HWTEST_F(ReminderDataManagerTest, IsMatched_00001, Level1)
852 {
853 sptr<ReminderRequest> reminder = new ReminderRequestTimer(50);
854 reminder->InitCreatorBundleName("test_IsMatched");
855 reminder->InitCreatorUid(98765);
856 reminder->InitBundleName("test_IsMatched");
857 reminder->InitUid(98765);
858 reminder->InitUserId(100);
859 bool ret = manager->IsMatched(reminder, 101, 98765, true);
860 EXPECT_EQ(ret, false);
861 ret = manager->IsMatched(reminder, 100, 98765, false);
862 EXPECT_EQ(ret, true);
863 ret = manager->IsMatched(reminder, 100, -1, false);
864 EXPECT_EQ(ret, false);
865 ret = manager->IsMatched(reminder, 100, -1, true);
866 EXPECT_EQ(ret, true);
867 }
868
869 /**
870 * @tc.name: ReminderEventManager_00001
871 * @tc.desc: Reminder data manager test
872 * @tc.type: FUNC
873 * @tc.require: issue#I9IIDE
874 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManager_001,Level1)875 HWTEST_F(ReminderDataManagerTest, ReminderEventManager_001, Level1)
876 {
877 MatchingSkills matchingSkills;
878 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
879 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
880 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
881 matchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
882 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED);
883 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
884 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_DATA_CLEARED);
885 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_PACKAGE_RESTARTED);
886 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
887 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
888 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
889 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_REMOVED);
890 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
891 auto subscriber = std::make_shared<ReminderEventManager::ReminderEventSubscriber>(subscriberInfo, manager);
892
893 EventFwk::Want want;
894 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 0);
895 AppExecFwk::ElementName element("", "test", "EntryAbility");
896 want.SetElement(element);
897 subscriber->HandlePackageRemove(want);
898 EXPECT_TRUE(manager != nullptr);
899 }
900
901 /**
902 * @tc.name: IsMatched_00001
903 * @tc.desc: Reminder data manager test
904 * @tc.type: FUNC
905 * @tc.require: issue#I9IIDE
906 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManager_002,Level1)907 HWTEST_F(ReminderDataManagerTest, ReminderEventManager_002, Level1)
908 {
909 auto statusChangeListener
910 = std::make_shared<ReminderEventManager::SystemAbilityStatusChangeListener>(manager);
911 statusChangeListener->OnAddSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, "");
912 statusChangeListener->OnAddSystemAbility(APP_MGR_SERVICE_ID, "");
913 statusChangeListener->OnAddSystemAbility(ABILITY_MGR_SERVICE_ID, "");
914 statusChangeListener->OnAddSystemAbility(-1, "");
915 statusChangeListener->OnRemoveSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, "");
916 statusChangeListener->OnRemoveSystemAbility(APP_MGR_SERVICE_ID, "");
917 statusChangeListener->OnRemoveSystemAbility(ABILITY_MGR_SERVICE_ID, "");
918 statusChangeListener->OnRemoveSystemAbility(-1, "");
919 EXPECT_TRUE(manager != nullptr);
920 }
921
922 /**
923 * @tc.name: ReminderEventManagerTest_005
924 * @tc.desc: Reminder data manager test
925 * @tc.type: FUNC
926 * @tc.require: issueI5YTF3
927 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_005,Level1)928 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_005, Level1)
929 {
930 MatchingSkills customMatchingSkills;
931 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
932 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
933 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
934 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
935 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
936 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CUSTOM_ALERT);
937 customMatchingSkills.AddEvent(ReminderRequest::REMINDER_EVENT_CLICK_ALERT);
938 CommonEventSubscribeInfo subscriberInfo(customMatchingSkills);
939 auto subscriber = std::make_shared<ReminderEventManager::ReminderEventCustomSubscriber>(subscriberInfo, manager);
940 EventFwk::CommonEventData data;
941 Want want;
942 want.SetAction(ReminderRequest::REMINDER_EVENT_ALARM_ALERT);
943 data.SetWant(want);
944 subscriber->OnReceiveEvent(data);
945 want.SetAction(ReminderRequest::REMINDER_EVENT_ALERT_TIMEOUT);
946 data.SetWant(want);
947 subscriber->OnReceiveEvent(data);
948 want.SetAction(ReminderRequest::REMINDER_EVENT_CLOSE_ALERT);
949 data.SetWant(want);
950 subscriber->OnReceiveEvent(data);
951 want.SetAction(ReminderRequest::REMINDER_EVENT_SNOOZE_ALERT);
952 data.SetWant(want);
953 subscriber->OnReceiveEvent(data);
954 want.SetAction(ReminderRequest::REMINDER_EVENT_REMOVE_NOTIFICATION);
955 data.SetWant(want);
956 subscriber->OnReceiveEvent(data);
957 want.SetAction(ReminderRequest::REMINDER_EVENT_CUSTOM_ALERT);
958 data.SetWant(want);
959 subscriber->OnReceiveEvent(data);
960 want.SetAction(ReminderRequest::REMINDER_EVENT_CLICK_ALERT);
961 data.SetWant(want);
962 subscriber->OnReceiveEvent(data);
963 EXPECT_TRUE(manager != nullptr);
964 }
965
966 /**
967 * @tc.name: ReminderEventManagerTest_006
968 * @tc.desc: Reminder data manager test
969 * @tc.type: FUNC
970 * @tc.require: issueI5YTF3
971 */
HWTEST_F(ReminderDataManagerTest,ReminderEventManagerTest_006,Level1)972 HWTEST_F(ReminderDataManagerTest, ReminderEventManagerTest_006, Level1)
973 {
974 std::shared_ptr<ReminderDataManager> data;
975 ReminderEventManager::ReminderNotificationSubscriber subscriber(data);
976 subscriber.OnCanceled(nullptr, nullptr, NotificationConstant::PACKAGE_REMOVE_REASON_DELETE);
977 subscriber.OnCanceled(nullptr, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
978 sptr<NotificationRequest> request = new NotificationRequest();
979 std::shared_ptr<Notification> notification = std::make_shared<Notification>(request);
980 subscriber.OnCanceled(notification, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
981 request->SetAutoDeletedTime(100);
982 subscriber.OnCanceled(notification, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
983 request->SetLabel("REMINDER_AGENT");
984 subscriber.OnCanceled(notification, nullptr, NotificationConstant::TRIGGER_AUTO_DELETE_REASON_DELETE);
985 EXPECT_TRUE(manager != nullptr);
986 }
987
988 /**
989 * @tc.name: ReminderDataManagerTest_020
990 * @tc.desc: Reminder data manager test
991 * @tc.type: FUNC
992 * @tc.require: issueI5YTF3
993 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_020,Level1)994 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_020, Level1)
995 {
996 sptr<ReminderRequest> reminder = new ReminderRequestTimer(500);
997 manager->CheckNeedNotifyStatus(reminder, ReminderRequest::ActionButtonType::CLOSE);
998 reminder->InitBundleName("test");
999 manager->CheckNeedNotifyStatus(reminder, ReminderRequest::ActionButtonType::CLOSE);
1000
1001 manager->isReminderAgentReady_ = false;
1002 manager->OnUnlockScreen();
1003 manager->isReminderAgentReady_ = true;
1004 auto queue = manager->queue_;
1005 manager->queue_ = nullptr;
1006 manager->OnUnlockScreen();
1007 manager->queue_ = queue;
1008
1009 EventFwk::Want want;
1010 manager->TerminateAlerting(want);
1011 manager->SnoozeReminder(want);
1012 manager->ClickReminder(want);
1013 manager->SnoozeReminderImpl(reminder);
1014 manager->OnLoadReminderEvent();
1015 manager->GetFullPath("1p");
1016 manager->PlaySoundAndVibration(nullptr);
1017 manager->RemoveReminderLocked(500, true);
1018 manager->RemoveReminderLocked(500, false);
1019 manager->ResetStates(ReminderDataManager::TimerType::ALERTING_TIMER);
1020 manager->ResetStates(static_cast<ReminderDataManager::TimerType>(100));
1021 manager->StopTimer(static_cast<ReminderDataManager::TimerType>(100));
1022 manager->ConnectAppMgr();
1023 manager->ConnectAppMgr();
1024 manager->OnRemoveAppMgr();
1025 Global::Resource::ResourceManager::RawFileDescriptor desc;
1026 manager->GetCustomRingFileDesc(reminder, desc);
1027 manager->CloseCustomRingFileDesc(500, "");
1028 manager->HandleAutoDeleteReminder(500, 100, 123456);
1029 std::map<std::string, sptr<ReminderRequest>> reminders;
1030 reminders["500"] = reminder;
1031 manager->UpdateShareReminders(reminders);
1032 EXPECT_TRUE(manager != nullptr);
1033 }
1034
1035 /**
1036 * @tc.name: ReminderDataManagerTest_021
1037 * @tc.desc: Reminder data manager test
1038 * @tc.type: FUNC
1039 * @tc.require: issueI5YTF3
1040 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_021,Level1)1041 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_021, Level1)
1042 {
1043 ReminderDataShareHelper::GetInstance().RegisterObserver();
1044 ReminderDataShareHelper::GetInstance().RegisterObserver();
1045 ReminderDataShareHelper::GetInstance().Update(1, 1);
1046 ReminderDataShareHelper::GetInstance().OnDataInsertOrDelete();
1047 ReminderDataShareHelper::GetInstance().OnDataInsertOrDelete();
1048 DataShare::DataShareObserver::ChangeInfo info;
1049 ReminderDataShareHelper::GetInstance().OnDataUpdate(info);
1050 info.valueBuckets_.resize(1);
1051 ReminderDataShareHelper::GetInstance().OnDataUpdate(info);
1052 ReminderDataShareHelper::GetInstance().UnRegisterObserver();
1053 ReminderDataShareHelper::GetInstance().UnRegisterObserver();
1054 auto helper = ReminderDataShareHelper::GetInstance().CreateDataShareHelper(ReminderCalendarShareTable::PROXY);
1055 ReminderDataShareHelper::GetInstance().ReleaseDataShareHelper(helper);
1056
1057 ReminderDataShareHelper::ReminderDataObserver observer;
1058 DataShare::DataShareObserver::ChangeInfo info1;
1059 info1.changeType_ = DataShare::DataShareObserver::ChangeType::INSERT;
1060 observer.OnChange(info1);
1061 info1.changeType_ = DataShare::DataShareObserver::ChangeType::UPDATE;
1062 observer.OnChange(info1);
1063 info1.changeType_ = DataShare::DataShareObserver::ChangeType::DELETE;
1064 observer.OnChange(info1);
1065 info1.changeType_ = DataShare::DataShareObserver::ChangeType::OTHER;
1066 observer.OnChange(info1);
1067 EXPECT_TRUE(manager != nullptr);
1068 }
1069
1070 /**
1071 * @tc.name: ReminderDataManagerTest_022
1072 * @tc.desc: Reminder data manager test
1073 * @tc.type: FUNC
1074 * @tc.require: issueI5YTF3
1075 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_022,Level1)1076 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_022, Level1)
1077 {
1078 ReminderConfigChangeObserver observer;
1079 AppExecFwk::Configuration config;
1080 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "");
1081 observer.OnConfigurationUpdated(config);
1082 config.RemoveItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1083 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, "test");
1084 observer.languageInfo_ = "test";
1085 observer.OnConfigurationUpdated(config);
1086 observer.languageInfo_ = "1111";
1087 observer.OnConfigurationUpdated(config);
1088 EXPECT_TRUE(manager != nullptr);
1089 }
1090
1091 /**
1092 * @tc.name: ReminderDataManagerTest_023
1093 * @tc.desc: Reminder data manager test
1094 * @tc.type: FUNC
1095 * @tc.require: issueI5YTF3
1096 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_023,Level1)1097 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_023, Level1)
1098 {
1099 sptr<ReminderRequest> reminder = new ReminderRequestTimer(500);
1100 auto buttonWantAgent = std::make_shared<ReminderRequest::ButtonWantAgent>();
1101 auto datashare = std::make_shared<ReminderRequest::ButtonDataShareUpdate>();
1102 reminder->SetActionButton("title", ReminderRequest::ActionButtonType::CLOSE, "resource",
1103 buttonWantAgent, datashare);
1104 manager->IsActionButtonDataShareValid(reminder, 0);
1105 datashare->uri = "1111";
1106 manager->IsActionButtonDataShareValid(reminder, 0);
1107
1108 std::unordered_map<std::string, int32_t> limits;
1109 int32_t totalCount = 0;
1110 reminder->InitUid(1);
1111 reminder->SetTriggerTimeInMilli(100);
1112 manager->CheckShowLimit(limits, totalCount, reminder);
1113 manager->CheckShowLimit(limits, totalCount, reminder);
1114 limits["1_100"] = 100;
1115 manager->CheckShowLimit(limits, totalCount, reminder);
1116 totalCount = 1000;
1117 manager->CheckShowLimit(limits, totalCount, reminder);
1118
1119 sleep(1);
1120 {
1121 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1122 manager->showedReminderVector_.push_back(reminder);
1123 }
1124 manager->HandleAutoDeleteReminder(231, 232, 233);
1125 reminder->InitUid(232);
1126 manager->HandleAutoDeleteReminder(231, 232, 233);
1127 reminder->SetNotificationId(231);
1128 manager->HandleAutoDeleteReminder(231, 232, 233);
1129 reminder->SetAutoDeletedTime(233);
1130 manager->HandleAutoDeleteReminder(231, 232, 233);
1131 {
1132 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1133 manager->showedReminderVector_.clear();
1134 }
1135 EXPECT_TRUE(manager != nullptr);
1136 }
1137
1138 /**
1139 * @tc.name: ReminderDataManagerTest_024
1140 * @tc.desc: Reminder data manager test
1141 * @tc.type: FUNC
1142 * @tc.require: issueI5YTF3
1143 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_024,Level1)1144 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_024, Level1)
1145 {
1146 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1147 timer->SetReminderId(241);
1148 sptr<ReminderRequest> calendar = new ReminderRequestCalendar();
1149 calendar->SetReminderId(242);
1150 {
1151 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1152 manager->reminderVector_.push_back(timer);
1153 manager->reminderVector_.push_back(calendar);
1154 }
1155 std::map<std::string, sptr<ReminderRequest>> reminders;
1156 manager->UpdateShareReminders(reminders);
1157 timer->SetShare(true);
1158 calendar->SetShare(true);
1159 manager->UpdateShareReminders(reminders);
1160 calendar->SetIdentifier("242");
1161 reminders["242"] = calendar;
1162 manager->UpdateShareReminders(reminders);
1163 manager->LoadShareReminders();
1164 {
1165 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1166 manager->reminderVector_.clear();
1167 }
1168 EXPECT_TRUE(manager != nullptr);
1169 }
1170
1171 /**
1172 * @tc.name: ReminderDataManagerTest_025
1173 * @tc.desc: Reminder data manager test
1174 * @tc.type: FUNC
1175 * @tc.require: issueI5YTF3
1176 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_025,Level1)1177 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_025, Level1)
1178 {
1179 DataShare::DataShareObserver::ChangeInfo info;
1180 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1181 info.valueBuckets_.resize(1);
1182
1183 DataShare::DataShareObserver::ChangeInfo::Value alarmTime = static_cast<double>(251);
1184 info.valueBuckets_[0][ReminderCalendarShareTable::ALARM_TIME] = alarmTime;
1185 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1186
1187 DataShare::DataShareObserver::ChangeInfo::Value id = static_cast<double>(252);
1188 info.valueBuckets_[0][ReminderCalendarShareTable::ID] = id;
1189 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1190
1191 DataShare::DataShareObserver::ChangeInfo::Value eventId = static_cast<double>(253);
1192 info.valueBuckets_[0][ReminderCalendarShareTable::EVENT_ID] = eventId;
1193 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1194
1195 DataShare::DataShareObserver::ChangeInfo::Value slotType = static_cast<double>(0);
1196 info.valueBuckets_[0][ReminderCalendarShareTable::SLOT_TYPE] = slotType;
1197 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1198
1199 DataShare::DataShareObserver::ChangeInfo::Value title = std::string("25");
1200 info.valueBuckets_[0][ReminderCalendarShareTable::TITLE] = title;
1201 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1202
1203 DataShare::DataShareObserver::ChangeInfo::Value content = std::string("255");
1204 info.valueBuckets_[0][ReminderCalendarShareTable::CONTENT] = content;
1205 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1206
1207 DataShare::DataShareObserver::ChangeInfo::Value buttons = std::string("");
1208 info.valueBuckets_[0][ReminderCalendarShareTable::BUTTONS] = buttons;
1209 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1210
1211 DataShare::DataShareObserver::ChangeInfo::Value wantAgent = std::string("");
1212 info.valueBuckets_[0][ReminderCalendarShareTable::WANT_AGENT] = wantAgent;
1213 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1214
1215 DataShare::DataShareObserver::ChangeInfo::Value identifier = std::string("256");
1216 info.valueBuckets_[0][ReminderCalendarShareTable::IDENTIFIER] = identifier;
1217 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1218
1219 DataShare::DataShareObserver::ChangeInfo::Value ends = static_cast<double>(1737948039000);
1220 info.valueBuckets_[0][ReminderCalendarShareTable::END] = ends;
1221 ReminderDataShareHelper::GetInstance().CreateReminder(info);
1222 EXPECT_TRUE(manager != nullptr);
1223 }
1224
1225 /**
1226 * @tc.name: ReminderDataManagerTest_026
1227 * @tc.desc: Reminder data manager test
1228 * @tc.type: FUNC
1229 * @tc.require: issueI5YTF3
1230 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_026,Level1)1231 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_026, Level1)
1232 {
1233 ReminderTimerInfo info;
1234 info.OnTrigger();
1235 info.SetReminderTimerType(ReminderTimerInfo::ReminderTimerType::REMINDER_TIMER_LOAD);
1236 info.OnTrigger();
1237 info.SetReminderTimerType(static_cast<ReminderTimerInfo::ReminderTimerType>(9));
1238 info.OnTrigger();
1239 EXPECT_TRUE(manager != nullptr);
1240 }
1241
1242 /**
1243 * @tc.name: ReminderDataManagerTest_027
1244 * @tc.desc: Reminder data manager test
1245 * @tc.type: FUNC
1246 * @tc.require: issueI5YTF3
1247 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_027,Level1)1248 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_027, Level1)
1249 {
1250 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1251 timer->SetReminderId(271);
1252 auto wantInfo = timer->wantAgentInfo_;
1253 timer->wantAgentInfo_ = nullptr;
1254 {
1255 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1256 manager->reminderVector_.push_back(timer);
1257 }
1258 EventFwk::Want want;
1259 want.SetParam(ReminderRequest::PARAM_REMINDER_ID, 271);
1260 manager->ClickReminder(want);
1261 {
1262 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1263 manager->reminderVector_.clear();
1264 manager->reminderVector_.push_back(timer);
1265 }
1266 timer->wantAgentInfo_ = wantInfo;
1267 manager->ClickReminder(want);
1268 {
1269 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1270 manager->reminderVector_.clear();
1271 manager->reminderVector_.push_back(timer);
1272 }
1273 timer->wantAgentInfo_->pkgName = "test";
1274 manager->ClickReminder(want);
1275 {
1276 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1277 manager->reminderVector_.clear();
1278 manager->reminderVector_.push_back(timer);
1279 }
1280 timer->SetSystemApp(true);
1281 manager->HandleCustomButtonClick(want);
1282 {
1283 std::lock_guard<std::mutex> locker(ReminderDataManager::MUTEX);
1284 manager->reminderVector_.clear();
1285 }
1286 EXPECT_TRUE(manager != nullptr);
1287 }
1288
1289 /**
1290 * @tc.name: ReminderDataManagerTest_028
1291 * @tc.desc: Reminder data manager test
1292 * @tc.type: FUNC
1293 * @tc.require: issueI5YTF3
1294 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_028,Level1)1295 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_028, Level1)
1296 {
1297 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1298 timer->SetReminderId(281);
1299 sptr<ReminderRequest> timer2 = new ReminderRequestTimer(500);
1300 timer2->SetReminderId(282);
1301 {
1302 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1303 manager->showedReminderVector_.push_back(timer);
1304 manager->showedReminderVector_.push_back(timer2);
1305 }
1306 manager->RemoveFromShowedReminders(timer);
1307 {
1308 std::lock_guard<std::mutex> lock(ReminderDataManager::SHOW_MUTEX);
1309 manager->showedReminderVector_.clear();
1310 }
1311 EXPECT_TRUE(manager != nullptr);
1312 }
1313
1314 /**
1315 * @tc.name: ReminderDataManagerTest_029
1316 * @tc.desc: Reminder data manager test
1317 * @tc.type: FUNC
1318 * @tc.require: issueI5YTF3
1319 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_029,Level1)1320 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_029, Level1)
1321 {
1322 manager->InitShareReminders(true);
1323 manager->InitShareReminders(false);
1324 manager->isReminderAgentReady_ = false;
1325 manager->OnUserSwitch(1);
1326 sleep(1);
1327 manager->isReminderAgentReady_ = true;
1328 auto queue = std::move(manager->queue_);
1329 manager->OnUserSwitch(1);
1330 sleep(1);
1331 manager->queue_ = std::move(queue);
1332 manager->OnUserSwitch(1);
1333 EXPECT_TRUE(manager != nullptr);
1334 sleep(1);
1335 }
1336
1337 /**
1338 * @tc.name: ReminderDataManagerTest_030
1339 * @tc.desc: Reminder data manager test
1340 * @tc.type: FUNC
1341 * @tc.require: issueI5YTF3
1342 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_030,Level1)1343 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_030, Level1)
1344 {
1345 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
1346 auto result = ReminderDataShareHelper::GetInstance().GetColumns();
1347 EXPECT_TRUE(result.size() == 19);
1348
1349 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
1350 result = ReminderDataShareHelper::GetInstance().GetColumns();
1351 EXPECT_TRUE(result.size() == 11);
1352
1353 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1354 DataShare::DataShareObserver::ChangeInfo::VBucket info;
1355
1356 DataShare::DataShareObserver::ChangeInfo::Value ringDuration = static_cast<double>(10);
1357 info[ReminderCalendarShareTable::RING_DURATION] = ringDuration;
1358 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
1359 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1360 EXPECT_TRUE(timer->GetRingDuration() == 1);
1361
1362 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
1363 info.clear();
1364 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1365 EXPECT_TRUE(timer->GetRingDuration() == 1);
1366
1367 DataShare::DataShareObserver::ChangeInfo::Value timeInterval1 = static_cast<double>(UINT64_MAX);
1368 info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval1;
1369 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1370 EXPECT_TRUE(timer->GetTimeInterval() == 0);
1371
1372 uint64_t testValue = UINT64_MAX / 500;
1373 DataShare::DataShareObserver::ChangeInfo::Value timeInterval2 = static_cast<double>(testValue);
1374 info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval2;
1375 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1376 EXPECT_TRUE(timer->GetTimeInterval() == 0);
1377
1378 testValue = UINT64_MAX / 1000 - 10;
1379 DataShare::DataShareObserver::ChangeInfo::Value timeInterval3 = static_cast<double>(testValue);
1380 info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval3;
1381 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1382 EXPECT_TRUE(timer->GetTimeInterval() < (UINT64_MAX / 1000));
1383
1384 DataShare::DataShareObserver::ChangeInfo::Value timeInterval4 = static_cast<double>(-100);
1385 info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval4;
1386 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1387 EXPECT_TRUE(timer->GetTimeInterval() == 0);
1388
1389 testValue = 10;
1390 DataShare::DataShareObserver::ChangeInfo::Value timeInterval5 = static_cast<double>(testValue);
1391 info[ReminderCalendarShareTable::TIME_INTERVAL] = timeInterval5;
1392 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1393 EXPECT_TRUE(timer->GetTimeInterval() == 30);
1394 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
1395 }
1396
1397 /**
1398 * @tc.name: ReminderDataManagerTest_031
1399 * @tc.desc: Reminder data manager test
1400 * @tc.type: FUNC
1401 * @tc.require: issueI5YTF3
1402 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_031,Level1)1403 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_031, Level1)
1404 {
1405 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
1406 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1407 DataShare::DataShareObserver::ChangeInfo::VBucket info;
1408 DataShare::DataShareObserver::ChangeInfo::Value snoozeTimes1 = static_cast<double>(UINT64_MAX);
1409 info[ReminderCalendarShareTable::SNOOZE_TIMES] = snoozeTimes1;
1410 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1411 EXPECT_TRUE(timer->GetSnoozeTimes() == UINT8_MAX);
1412
1413 DataShare::DataShareObserver::ChangeInfo::Value snoozeTimes2 = static_cast<double>(-1);
1414 info[ReminderCalendarShareTable::SNOOZE_TIMES] = snoozeTimes2;
1415 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1416 EXPECT_TRUE(timer->GetSnoozeTimes() <= UINT8_MAX);
1417
1418 uint64_t testValue = 5;
1419 DataShare::DataShareObserver::ChangeInfo::Value snoozeTimes3 = static_cast<double>(testValue);
1420 info[ReminderCalendarShareTable::SNOOZE_TIMES] = snoozeTimes3;
1421 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1422 EXPECT_TRUE(timer->GetSnoozeTimes() == testValue);
1423
1424 DataShare::DataShareObserver::ChangeInfo::Value ringDuration1 = static_cast<double>(UINT64_MAX);
1425 info[ReminderCalendarShareTable::RING_DURATION] = ringDuration1;
1426 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1427 EXPECT_TRUE(timer->GetRingDuration() == 0);
1428
1429 testValue = UINT64_MAX / 500;
1430 DataShare::DataShareObserver::ChangeInfo::Value ringDuration2 = static_cast<double>(testValue);
1431 info[ReminderCalendarShareTable::RING_DURATION] = ringDuration2;
1432 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1433 EXPECT_TRUE(timer->GetRingDuration() == 0);
1434
1435 testValue = UINT64_MAX / 1000 - 10;
1436 DataShare::DataShareObserver::ChangeInfo::Value ringDuration3 = static_cast<double>(testValue);
1437 info[ReminderCalendarShareTable::RING_DURATION] = ringDuration3;
1438 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1439 EXPECT_TRUE(timer->GetRingDuration() == ReminderRequest::MAX_RING_DURATION / 1000);
1440
1441 DataShare::DataShareObserver::ChangeInfo::Value ringDuration4 = static_cast<double>(-100);
1442 info[ReminderCalendarShareTable::RING_DURATION] = ringDuration4;
1443 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1444 EXPECT_TRUE(timer->GetRingDuration() == 0);
1445
1446 testValue = 10;
1447 DataShare::DataShareObserver::ChangeInfo::Value ringDuration5 = static_cast<double>(testValue);
1448 info[ReminderCalendarShareTable::RING_DURATION] = ringDuration5;
1449 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1450 EXPECT_TRUE(timer->GetRingDuration() == testValue);
1451 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
1452 }
1453
1454 /**
1455 * @tc.name: ReminderDataManagerTest_032
1456 * @tc.desc: Reminder data manager test
1457 * @tc.type: FUNC
1458 * @tc.require: issueI5YTF3
1459 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_032,Level1)1460 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_032, Level1)
1461 {
1462 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = true;
1463 sptr<ReminderRequest> timer = new ReminderRequestTimer(500);
1464 DataShare::DataShareObserver::ChangeInfo::VBucket info;
1465 DataShare::DataShareObserver::ChangeInfo::Value type = static_cast<double>(1);
1466 info[ReminderCalendarShareTable::SNOOZE_SLOT_TYPE] = type;
1467 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1468 int32_t result = static_cast<int32_t>(timer->GetSnoozeSlotType());
1469 EXPECT_TRUE(result == 1);
1470
1471 std::string testValue;
1472 DataShare::DataShareObserver::ChangeInfo::Value snoozeContent1 = testValue;
1473 info[ReminderCalendarShareTable::SNOOZE_CONTENT] = snoozeContent1;
1474 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1475 EXPECT_TRUE(timer->GetSnoozeContent() == testValue);
1476
1477 DataShare::DataShareObserver::ChangeInfo::Value expiredContent1 = testValue;
1478 info[ReminderCalendarShareTable::EXPIRED_CONTENT] = expiredContent1;
1479 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1480 EXPECT_TRUE(timer->GetExpiredContent() == testValue);
1481
1482 DataShare::DataShareObserver::ChangeInfo::Value uri1 = testValue;
1483 info[ReminderCalendarShareTable::CUSTOM_RING_URI] = uri1;
1484 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1485 EXPECT_TRUE(timer->GetCustomRingUri() == testValue);
1486
1487 testValue = "testValue";
1488 DataShare::DataShareObserver::ChangeInfo::Value snoozeContent2 = testValue;
1489 info[ReminderCalendarShareTable::SNOOZE_CONTENT] = snoozeContent2;
1490 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1491 EXPECT_TRUE(timer->GetSnoozeContent() == testValue);
1492
1493 DataShare::DataShareObserver::ChangeInfo::Value expiredContent2 = testValue;
1494 info[ReminderCalendarShareTable::EXPIRED_CONTENT] = expiredContent2;
1495 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1496 EXPECT_TRUE(timer->GetExpiredContent() == testValue);
1497
1498 DataShare::DataShareObserver::ChangeInfo::Value uri2 = testValue;
1499 info[ReminderCalendarShareTable::CUSTOM_RING_URI] = uri2;
1500 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1501 EXPECT_TRUE(timer->GetCustomRingUri() == testValue);
1502
1503 testValue = "";
1504 DataShare::DataShareObserver::ChangeInfo::Value wantAgent1 = testValue;
1505 info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent1;
1506 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1507 EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == testValue);
1508
1509 testValue = "iodahfoibnaoje";
1510 DataShare::DataShareObserver::ChangeInfo::Value wantAgent2 = testValue;
1511 info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent2;
1512 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1513 EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "");
1514
1515 testValue = R"(1)";
1516 DataShare::DataShareObserver::ChangeInfo::Value wantAgent3 = testValue;
1517 info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent3;
1518 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1519 EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "");
1520
1521 testValue = R"({})";
1522 DataShare::DataShareObserver::ChangeInfo::Value wantAgent4 = testValue;
1523 info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent4;
1524 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1525 EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "");
1526
1527 testValue = R"({"pkgName": "com.aaa.aaa", "abilityName": "Entry"})";
1528 DataShare::DataShareObserver::ChangeInfo::Value wantAgent5 = testValue;
1529 info[ReminderCalendarShareTable::MAX_SCREEN_WANT_AGENT] = wantAgent5;
1530 ReminderDataShareHelper::GetInstance().BuildReminderV1(info, timer);
1531 EXPECT_TRUE(timer->maxScreenWantAgentInfo_->abilityName == "Entry");
1532 ReminderDataShareHelper::GetInstance().isNewRdbVer_ = false;
1533 }
1534
1535 /**
1536 * @tc.name: ReminderDataManagerTest_033
1537 * @tc.desc: Reminder data manager test
1538 * @tc.type: FUNC
1539 * @tc.require: issueI5YTF3
1540 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_033,Level1)1541 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_033, Level1)
1542 {
1543 sptr<ReminderRequest> calendar = new ReminderRequestCalendar(300);
1544 calendar->triggerTimeInMilli_ = 0;
1545 manager->UpdateAndSaveReminderLocked(calendar, false);
1546 EXPECT_TRUE(calendar->isExpired_ == true);
1547 calendar->triggerTimeInMilli_ = ::time(nullptr) * 1000 + 30 * 60 * 1000;
1548 manager->UpdateAndSaveReminderLocked(calendar, true);
1549 calendar->reminderId_ = 301;
1550 manager->UpdateAndSaveReminderLocked(calendar, true);
1551 calendar->reminderId_ = 300;
1552 calendar->isShare_ = true;
1553 manager->UpdateAndSaveReminderLocked(calendar, true);
1554 calendar->isShare_ = false;
1555 manager->UpdateAndSaveReminderLocked(calendar, true);
1556 EXPECT_TRUE(manager != nullptr);
1557 }
1558
1559 /**
1560 * @tc.name: ReminderDataManagerTest_034
1561 * @tc.desc: Reminder data manager test
1562 * @tc.type: FUNC
1563 * @tc.require: issueI5YTF3
1564 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_034,Level1)1565 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_034, Level1)
1566 {
1567 manager->ReportTimerEvent(0, false);
1568 int64_t targetTime = GetCurrentTime();
1569 manager->ReportTimerEvent(targetTime, false);
1570 targetTime -= 60 * 60 * 1000;
1571 manager->ReportTimerEvent(targetTime, false);
1572 EXPECT_TRUE(manager != nullptr);
1573 }
1574
1575 /**
1576 * @tc.name: ReminderDataManagerTest_035
1577 * @tc.desc: Reminder data manager test
1578 * @tc.type: FUNC
1579 * @tc.require: issueI5YTF3
1580 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_035,Level1)1581 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_035, Level1)
1582 {
1583 sptr<ReminderRequest> calendar = new ReminderRequestCalendar(300);
1584 calendar->SetSystemApp(true);
1585 int32_t count = 0;
1586 manager->AsyncStartExtensionAbility(calendar, 1, 1, count);
1587 manager->AsyncStartExtensionAbility(calendar, 0, 1, count);
1588 count = 200;
1589 manager->AsyncStartExtensionAbility(calendar, 0, 1, count);
1590 EXPECT_TRUE(manager != nullptr);
1591 }
1592
1593 /**
1594 * @tc.name: ReminderDataManagerTest_036
1595 * @tc.desc: Reminder data manager test
1596 * @tc.type: FUNC
1597 * @tc.require: issueI5YTF3
1598 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_036,Level1)1599 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_036, Level1)
1600 {
1601 auto ret = manager->ConvertRingChannel(ReminderRequest::RingChannel::ALARM);
1602 EXPECT_TRUE(ret == AudioStandard::StreamUsage::STREAM_USAGE_ALARM);
1603 ret = manager->ConvertRingChannel(ReminderRequest::RingChannel::MEDIA);
1604 EXPECT_TRUE(ret == AudioStandard::StreamUsage::STREAM_USAGE_MEDIA);
1605 ret = manager->ConvertRingChannel(ReminderRequest::RingChannel::NOTIFICATION);
1606 EXPECT_TRUE(ret == AudioStandard::StreamUsage::STREAM_USAGE_NOTIFICATION);
1607 ret = manager->ConvertRingChannel(static_cast<ReminderRequest::RingChannel>(-1));
1608 EXPECT_TRUE(ret == AudioStandard::StreamUsage::STREAM_USAGE_ALARM);
1609 }
1610
1611 /**
1612 * @tc.name: ReminderDataManagerTest_037
1613 * @tc.desc: Reminder data manager test
1614 * @tc.type: FUNC
1615 * @tc.require: issueI5YTF3
1616 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_037,Level1)1617 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_037, Level1)
1618 {
1619 sptr<ReminderRequest> calendar = new ReminderRequestCalendar(300);
1620 calendar->InitBundleName("com.test.test");
1621 calendar->InitUid(999);
1622 calendar->SetShare(true);
1623 manager->PlaySoundAndVibration(calendar);
1624 auto ret = manager->CheckSoundConfig(calendar);
1625 EXPECT_TRUE(ret == false);
1626 }
1627
1628 /**
1629 * @tc.name: ReminderDataManagerTest_038
1630 * @tc.desc: Reminder data manager test
1631 * @tc.type: FUNC
1632 * @tc.require: issueI5YTF3
1633 */
HWTEST_F(ReminderDataManagerTest,ReminderDataManagerTest_038,Level1)1634 HWTEST_F(ReminderDataManagerTest, ReminderDataManagerTest_038, Level1)
1635 {
1636 std::string uriStr = "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_100"
1637 "?Proxy=true&key=focus_mode_enable";
1638 Uri enableUri(uriStr);
1639 std::string enable;
1640 auto ret = ReminderDataShareHelper::GetInstance().Query(enableUri, "focus_mode_enable", enable);
1641 EXPECT_TRUE(ret == false);
1642 }
1643 } // namespace Notification
1644 } // namespace OHOS
1645