1 /*
2  * Copyright (c) 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 <gtest/gtest.h>
17 
18 #define private public
19 #define protected public
20 #include "reminder_store.h"
21 #include "reminder_table.h"
22 #include "reminder_table_old.h"
23 #include "reminder_request_alarm.h"
24 #include "reminder_request_calendar.h"
25 #include "reminder_request_timer.h"
26 #undef private
27 #undef protected
28 #include "reminder_helper.h"
29 #include "notification_preferences.h"
30 
31 using namespace testing::ext;
32 namespace OHOS {
33 namespace Notification {
34 namespace {
35     constexpr int32_t NON_SYSTEM_APP_UID = 1000;
36     const std::string TEST_DEFUALT_BUNDLE = "bundleName";
37     const int32_t STATE_FAIL = -1;
38 }
39 class ReminderStoreTest : public testing::Test {
40 public:
SetUpTestCase()41     static void SetUpTestCase()
42     {
43         ReminderHelper::CancelAllReminders();
44     }
TearDownTestCase()45     static void TearDownTestCase() {}
SetUp()46     void SetUp() {}
TearDown()47     void TearDown()
48     {
49         ReminderHelper::CancelAllReminders();
50         NativeRdb::RdbHelper::DeleteRdbStore(ReminderStore::REMINDER_DB_DIR + ReminderStore::REMINDER_DB_NAME);
51     }
52 
InitStore(ReminderStore & store)53     void InitStore(ReminderStore& store)
54     {
55         std::string dbConfig = ReminderStore::REMINDER_DB_DIR + "notification_test.db";
56         NativeRdb::RdbStoreConfig config(dbConfig);
57         config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
58         {
59             ReminderStore::ReminderStoreDataCallBack rdbDataCallBack;
60             int32_t errCode = STATE_FAIL;
61             constexpr int32_t version = 7;
62             store.rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, version, rdbDataCallBack, errCode);
63         }
64     }
65 
ClearStore()66     void ClearStore()
67     {
68         NativeRdb::RdbHelper::ClearCache();
69         NativeRdb::RdbHelper::DeleteRdbStore(ReminderStore::REMINDER_DB_DIR + "notification_test.db");
70     }
71     static sptr<NotificationBundleOption> bundleOption_;
72 };
73 
74 sptr<NotificationBundleOption> ReminderStoreTest::bundleOption_ =
75     new NotificationBundleOption(TEST_DEFUALT_BUNDLE, NON_SYSTEM_APP_UID);
76 
77 /**
78  * @tc.name: Init_00001
79  * @tc.desc: Test Init parameters.
80  * @tc.type: FUNC
81  * @tc.require: issueI5VB6V
82  */
83 HWTEST_F(ReminderStoreTest, Init_00001, Function | SmallTest | Level1)
84 {
85     ReminderStore reminderStore;
86     int32_t ret = reminderStore.Init();
87     EXPECT_EQ(ret, 0);
88 }
89 
90 /**
91  * @tc.name: InitData_00001
92  * @tc.desc: Test InitData parameters.
93  * @tc.type: FUNC
94  * @tc.require: issueI5VB6V
95  */
96 HWTEST_F(ReminderStoreTest, InitData_00001, Function | SmallTest | Level1)
97 {
98     ReminderStore reminderStore;
99     int32_t ret = reminderStore.InitData();
100     EXPECT_EQ(ret, -1);
101 }
102 
103 /**
104  * @tc.name: Delete_00001
105  * @tc.desc: Test Delete parameters.
106  * @tc.type: FUNC
107  * @tc.require: issueI5VB6V
108  */
109 HWTEST_F(ReminderStoreTest, Delete_00001, Function | SmallTest | Level1)
110 {
111     int32_t reminderId = 1;
112     ReminderStore reminderStore;
113     int32_t ret = reminderStore.Delete(reminderId);
114     EXPECT_EQ(ret, -1);
115 }
116 
117 /**
118  * @tc.name: Delete_00002
119  * @tc.desc: Test Delete parameters.
120  * @tc.type: FUNC
121  * @tc.require: issueI5VB6V
122  */
123 HWTEST_F(ReminderStoreTest, Delete_00002, Function | SmallTest | Level1)
124 {
125     std::string pkg = "pkg";
126     int32_t userId = 1;
127     ReminderStore reminderStore;
128     int32_t ret = reminderStore.Delete(pkg, userId, -1);
129     EXPECT_EQ(ret, -1);
130 }
131 
132 /**
133  * @tc.name: Delete_00003
134  * @tc.desc: Test Delete parameters.
135  * @tc.type: FUNC
136  * @tc.require: issueI5VB6V
137  */
138 HWTEST_F(ReminderStoreTest, Delete_00003, Function | SmallTest | Level1)
139 {
140     std::string deleteCondition = "deleteCondition";
141     ReminderStore reminderStore;
142     int32_t ret = reminderStore.DeleteBase(deleteCondition);
143     EXPECT_EQ(ret, -1);
144 }
145 
146 /**
147  * @tc.name: Insert_00001
148  * @tc.desc: Test Insert parameters.
149  * @tc.type: FUNC
150  * @tc.require: issueI5VB6V
151  */
152 HWTEST_F(ReminderStoreTest, Insert_00001, Function | SmallTest | Level1)
153 {
154     sptr<ReminderRequest> reminder = nullptr;
155     ReminderStore reminderStore;
156     int64_t ret = reminderStore.Insert(reminder, bundleOption_);
157     EXPECT_EQ(ret, -1);
158 }
159 
160 /**
161  * @tc.name: Update_00001
162  * @tc.desc: Test Update parameters.
163  * @tc.type: FUNC
164  * @tc.require: issueI5VB6V
165  */
166 HWTEST_F(ReminderStoreTest, Update_00001, Function | SmallTest | Level1)
167 {
168     sptr<ReminderRequest> reminder = nullptr;
169     ReminderStore reminderStore;
170     int64_t ret = reminderStore.Update(reminder, bundleOption_);
171     EXPECT_EQ(ret, -1);
172 }
173 
174 /**
175  * @tc.name: Query_00001
176  * @tc.desc: Test Query parameters.
177  * @tc.type: FUNC
178  * @tc.require: issueI5VB6V
179  */
180 HWTEST_F(ReminderStoreTest, Query_00001, Function | SmallTest | Level1)
181 {
182     std::string queryCondition = "queryCondition";
183     std::string name = "it";
184     ReminderStore reminderStore;
185     std::shared_ptr<NativeRdb::ResultSet> ret = reminderStore.Query(queryCondition);
186     EXPECT_EQ(ret, nullptr);
187 }
188 
189 /**
190  * @tc.name: GetMaxId_00001
191  * @tc.desc: Test GetMaxId parameters.
192  * @tc.type: FUNC
193  * @tc.require: issueI5VB6V
194  */
195 HWTEST_F(ReminderStoreTest, GetMaxId_00001, Function | SmallTest | Level1)
196 {
197     ReminderStore reminderStore;
198     int32_t ret = reminderStore.GetMaxId();
199     EXPECT_EQ(ret, STATE_FAIL);
200 }
201 
202 /**
203  * @tc.name: GetAllValidReminders_00001
204  * @tc.desc: Test GetAllValidReminders parameters.
205  * @tc.type: FUNC
206  * @tc.require: issueI5VB6V
207  */
208 HWTEST_F(ReminderStoreTest, GetAllValidReminders_00001, Function | SmallTest | Level1)
209 {
210     ReminderStore reminderStore;
211     std::vector<sptr<ReminderRequest>> ret = reminderStore.GetAllValidReminders();
212     EXPECT_EQ(ret.size(), 0);
213 }
214 
215 /**
216  * @tc.name: GetReminders_00001
217  * @tc.desc: Test GetReminders parameters.
218  * @tc.type: FUNC
219  * @tc.require: issueI5VB6V
220  */
221 HWTEST_F(ReminderStoreTest, GetReminders_00001, Function | SmallTest | Level1)
222 {
223     std::string queryCondition = "queryCondition";
224     ReminderStore reminderStore;
225     std::vector<sptr<ReminderRequest>> ret = reminderStore.GetReminders(queryCondition);
226     EXPECT_EQ(ret.size(), 0);
227 }
228 
229 /**
230  * @tc.name: Query_00002
231  * @tc.desc: Test Query parameters.
232  * @tc.type: FUNC
233  * @tc.require: issueI92BU9
234  */
235 HWTEST_F(ReminderStoreTest, Query_00002, Function | SmallTest | Level1)
236 {
237     std::string tableName = "reminder_base";
238     std::string colums = "reminder_type";
239     int32_t reminderId = 0;
240     ReminderStore reminderStore;
241     std::shared_ptr<NativeRdb::ResultSet> ret = reminderStore.Query(tableName,
242         colums, reminderId);
243     EXPECT_EQ(ret, nullptr);
244 }
245 
246 /**
247  * @tc.name: Delete_00004
248  * @tc.desc: Test Delete parameters.
249  * @tc.type: FUNC
250  * @tc.require: issueI92BU9
251  */
252 HWTEST_F(ReminderStoreTest, Delete_00004, Function | SmallTest | Level1)
253 {
254     std::string conditiont1 = "deleteCondition1";
255     std::string conditiont2 = "deleteCondition2";
256     ReminderStore reminderStore;
257     int32_t ret = reminderStore.Delete(conditiont1, conditiont2);
258     EXPECT_EQ(ret, -1);
259 }
260 
261 /**
262  * @tc.name: DeleteUser_00004
263  * @tc.desc: Test DeleteUser parameters.
264  * @tc.type: FUNC
265  * @tc.require: issueI92BU9
266  */
267 HWTEST_F(ReminderStoreTest, DeleteUser_00004, Function | SmallTest | Level1)
268 {
269     int32_t userId = 0;
270     ReminderStore reminderStore;
271     int32_t ret = reminderStore.DeleteUser(userId);
272     EXPECT_EQ(ret, -1);
273 }
274 
275 /**
276  * @tc.name: UpdateOrInsert_00001
277  * @tc.desc: Test UpdateOrInsert parameters.
278  * @tc.type: FUNC
279  * @tc.require: issueI92BU9
280  */
281 HWTEST_F(ReminderStoreTest, UpdateOrInsert_00001, Function | SmallTest | Level1)
282 {
283     sptr<ReminderRequest> reminder = nullptr;
284     ReminderStore reminderStore;
285     int64_t ret = reminderStore.UpdateOrInsert(reminder, bundleOption_);
286     EXPECT_EQ(ret, -1);
287 }
288 
289 /**
290  * @tc.name: OnCreate_00001
291  * @tc.desc: Test OnCreate parameters.
292  * @tc.type: FUNC
293  * @tc.require: issueI92BU9
294  */
295 HWTEST_F(ReminderStoreTest, OnCreate_00001, Function | SmallTest | Level1)
296 {
297     std::string dbConfig = ReminderStore::REMINDER_DB_DIR + "notification_test.db";
298     NativeRdb::RdbStoreConfig config(dbConfig);
299     config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
300     {
301         ReminderStore::ReminderStoreDataCallBack rdbDataCallBack;
302         int32_t errCode = STATE_FAIL;
303         auto rdbStore = NativeRdb::RdbHelper::GetRdbStore(config, 5, rdbDataCallBack, errCode);
304         EXPECT_NE(rdbStore, nullptr);
305     }
306     NativeRdb::RdbHelper::ClearCache();
307     NativeRdb::RdbHelper::DeleteRdbStore(ReminderStore::REMINDER_DB_DIR + "notification_test.db");
308 }
309 
310 /**
311  * @tc.name: Delete_00005
312  * @tc.desc: Test OnCreate parameters.
313  * @tc.type: FUNC
314  * @tc.require: issueI92BU9
315  */
316 HWTEST_F(ReminderStoreTest, Delete_00005, Function | SmallTest | Level1)
317 {
318     ReminderStore reminderStore;
319     int32_t ret = reminderStore.Delete("com.example.simple", 100, 20020152);
320     EXPECT_EQ(ret, -1);
321 
322     ret = reminderStore.Delete("com.example.simple", 100, -1);
323     EXPECT_EQ(ret, -1);
324 }
325 
326 /**
327  * @tc.name: ReminderStrategyTest_00001
328  * @tc.desc: Test OnCreate parameters.
329  * @tc.type: FUNC
330  * @tc.require: issueI92BU9
331  */
332 HWTEST_F(ReminderStoreTest, ReminderTimerStrategyTest_00001, Function | SmallTest | Level1)
333 {
334     ReminderStore reminderStore;
335     InitStore(reminderStore);
336     sptr<ReminderRequest> reminder = new ReminderRequestTimer();
337     reminder->reminderId_ = 999;
338     reminder->bundleName_ = "ReminderTimerStrategyTest_00001";
339     reminder->userId_ = 998;
340     reminder->uid_ = 997;
341     reminder->isSystemApp_ = true;
342     reminder->reminderType_ = ReminderRequest::ReminderType::TIMER;
343     reminder->reminderTimeInMilli_ = 123456789;
344     reminder->triggerTimeInMilli_ = 987654321;
345     reminder->SetTimeInterval(100);
346     reminder->snoozeTimes_ = 10;
347     reminder->snoozeTimesDynamic_ = 9;
348     reminder->SetRingDuration(500);
349     reminder->isExpired_ = false;
350     reminder->state_ = 123;
351     ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr());
352     timer->countDownTimeInSeconds_ = 10001;
353 
354     sptr<NotificationBundleOption> bundleOption = new NotificationBundleOption("test", 101);
355     reminderStore.UpdateOrInsert(reminder, bundleOption);
356     auto reminders = reminderStore.GetAllValidReminders();
357     bool succeed = false;
358     for (auto each : reminders) {
359         if (each->reminderId_ != reminder->reminderId_) {
360             continue;
361         }
362 
363         EXPECT_EQ(reminder->bundleName_, each->bundleName_);
364         EXPECT_EQ(reminder->userId_, each->userId_);
365         EXPECT_EQ(reminder->uid_, each->uid_);
366         EXPECT_EQ(reminder->isSystemApp_, each->isSystemApp_);
367         EXPECT_EQ(reminder->reminderType_, each->reminderType_);
368         EXPECT_EQ(reminder->reminderTimeInMilli_, each->reminderTimeInMilli_);
369         EXPECT_EQ(reminder->triggerTimeInMilli_, each->triggerTimeInMilli_);
370         EXPECT_EQ(reminder->GetTimeInterval(), each->GetTimeInterval());
371         EXPECT_EQ(reminder->snoozeTimes_, each->snoozeTimes_);
372         EXPECT_EQ(reminder->snoozeTimesDynamic_, each->snoozeTimesDynamic_);
373         EXPECT_EQ(reminder->GetRingDuration(), each->GetRingDuration());
374         EXPECT_EQ(reminder->isExpired_, each->isExpired_);
375         EXPECT_EQ(reminder->state_, each->state_);
376         ReminderRequestTimer* timer1 = static_cast<ReminderRequestTimer*>(each.GetRefPtr());
377         EXPECT_EQ(timer1->countDownTimeInSeconds_, timer->countDownTimeInSeconds_);
378         succeed = true;
379         break;
380     }
381     reminderStore.Delete(reminder->reminderId_);
382     EXPECT_EQ(succeed, true);
383     ClearStore();
384 }
385 
386 /**
387  * @tc.name: ReminderTimerStrategyTest_00002
388  * @tc.desc: Test OnCreate parameters.
389  * @tc.type: FUNC
390  * @tc.require: issueI92BU9
391  */
392 HWTEST_F(ReminderStoreTest, ReminderTimerStrategyTest_00002, Function | SmallTest | Level1)
393 {
394     ReminderStore reminderStore;
395     InitStore(reminderStore);
396     sptr<ReminderRequest> reminder = new ReminderRequestTimer();
397     reminder->reminderId_ = 999;
398     reminder->reminderType_ = ReminderRequest::ReminderType::TIMER;
399     reminder->slotType_ = static_cast<NotificationConstant::SlotType>(1);
400     reminder->snoozeSlotType_ = static_cast<NotificationConstant::SlotType>(1);
401     reminder->notificationId_ = 123;
402     reminder->title_ = "title_";
403     reminder->content_ = "content_";
404     reminder->snoozeContent_ = "snoozeContent_";
405     reminder->expiredContent_ = "expiredContent_";
406     reminder->tapDismissed_ = false;
407     reminder->autoDeletedTime_ = 666;
408     reminder->groupId_ = "groupId_";
409     reminder->customRingUri_ = "customRingUri_";
410     reminder->creatorBundleName_ = "creatorBundleName_";
411     reminder->creatorUid_ = 101;
412     ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr());
413     timer->countDownTimeInSeconds_ = 10001;
414 
415     sptr<NotificationBundleOption> bundleOption = new NotificationBundleOption("test", 101);
416     reminderStore.UpdateOrInsert(reminder, bundleOption);
417     auto reminders = reminderStore.GetAllValidReminders();
418     bool succeed = false;
419     for (auto each : reminders) {
420         if (each->reminderId_ != reminder->reminderId_) {
421             continue;
422         }
423 
424         EXPECT_EQ(reminder->slotType_, each->slotType_);
425         EXPECT_EQ(reminder->snoozeSlotType_, each->snoozeSlotType_);
426         EXPECT_EQ(reminder->notificationId_, each->notificationId_);
427         EXPECT_EQ(reminder->title_, each->title_);
428         EXPECT_EQ(reminder->content_, each->content_);
429         EXPECT_EQ(reminder->snoozeContent_, each->snoozeContent_);
430         EXPECT_EQ(reminder->expiredContent_, each->expiredContent_);
431         EXPECT_EQ(reminder->tapDismissed_, each->tapDismissed_);
432         EXPECT_EQ(reminder->autoDeletedTime_, each->autoDeletedTime_);
433         EXPECT_EQ(reminder->groupId_, each->groupId_);
434         EXPECT_EQ(reminder->customRingUri_, each->customRingUri_);
435         EXPECT_EQ(reminder->creatorBundleName_, each->creatorBundleName_);
436         EXPECT_EQ(reminder->creatorUid_, each->creatorUid_);
437         succeed = true;
438         break;
439     }
440     reminderStore.Delete(reminder->reminderId_);
441     EXPECT_EQ(succeed, true);
442     ClearStore();
443 }
444 
445 /**
446  * @tc.name: ReminderTimerStrategyTest_00003
447  * @tc.desc: Test OnCreate parameters.
448  * @tc.type: FUNC
449  * @tc.require: issueI92BU9
450  */
451 HWTEST_F(ReminderStoreTest, ReminderTimerStrategyTest_00003, Function | SmallTest | Level1)
452 {
453     ReminderStore reminderStore;
454     InitStore(reminderStore);
455     sptr<ReminderRequest> reminder = new ReminderRequestTimer();
456     reminder->reminderId_ = 999;
457     reminder->reminderType_ = ReminderRequest::ReminderType::TIMER;
458     reminder->customButtonUri_ = "customButtonUri_";
459     if (reminder->wantAgentInfo_ == nullptr) {
460         reminder->InitServerObj();
461     }
462     reminder->wantAgentInfo_->pkgName = "pkgName";
463     reminder->wantAgentInfo_->abilityName = "abilityName";
464     reminder->wantAgentInfo_->uri = "uri";
465     reminder->maxScreenWantAgentInfo_->pkgName = "pkgName1";
466     reminder->maxScreenWantAgentInfo_->abilityName = "abilityName1";
467     ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr());
468     timer->countDownTimeInSeconds_ = 10001;
469 
470     sptr<NotificationBundleOption> bundleOption = new NotificationBundleOption("test", 101);
471     reminderStore.UpdateOrInsert(reminder, bundleOption);
472     auto reminders = reminderStore.GetAllValidReminders();
473     bool succeed = false;
474     for (auto each : reminders) {
475         if (each->reminderId_ != reminder->reminderId_) {
476             continue;
477         }
478 
479         EXPECT_EQ(reminder->customButtonUri_, each->customButtonUri_);
480         EXPECT_EQ(reminder->wantAgentInfo_->pkgName, each->wantAgentInfo_->pkgName);
481         EXPECT_EQ(reminder->wantAgentInfo_->abilityName, each->wantAgentInfo_->abilityName);
482         EXPECT_EQ(reminder->wantAgentInfo_->uri, each->wantAgentInfo_->uri);
483         EXPECT_EQ(reminder->maxScreenWantAgentInfo_->pkgName, each->maxScreenWantAgentInfo_->pkgName);
484         EXPECT_EQ(reminder->maxScreenWantAgentInfo_->abilityName, each->maxScreenWantAgentInfo_->abilityName);
485         succeed = true;
486         break;
487     }
488     reminderStore.Delete(reminder->reminderId_);
489     EXPECT_EQ(succeed, true);
490     ClearStore();
491 }
492 
493 /**
494  * @tc.name: ReminderAlarmStrategyTest_00001
495  * @tc.desc: Test OnCreate parameters.
496  * @tc.type: FUNC
497  * @tc.require: issueI92BU9
498  */
499 HWTEST_F(ReminderStoreTest, ReminderAlarmStrategyTest_00001, Function | SmallTest | Level1)
500 {
501     ReminderStore reminderStore;
502     InitStore(reminderStore);
503     sptr<ReminderRequest> reminder = new ReminderRequestAlarm();
504     reminder->reminderId_ = 999;
505     reminder->reminderType_ = ReminderRequest::ReminderType::ALARM;
506     reminder->repeatDaysOfWeek_ = 55;
507     ReminderRequestAlarm* alarm = static_cast<ReminderRequestAlarm*>(reminder.GetRefPtr());
508     alarm->hour_ = 12;
509     alarm->minute_ = 30;
510 
511     sptr<NotificationBundleOption> bundleOption = new NotificationBundleOption("test", 101);
512     reminderStore.UpdateOrInsert(reminder, bundleOption);
513     auto reminders = reminderStore.GetAllValidReminders();
514     bool succeed = false;
515     for (auto each : reminders) {
516         if (each->reminderId_ != reminder->reminderId_) {
517             continue;
518         }
519 
520         EXPECT_EQ(reminder->repeatDaysOfWeek_, each->repeatDaysOfWeek_);
521         ReminderRequestAlarm* alarm1 = static_cast<ReminderRequestAlarm*>(each.GetRefPtr());
522         EXPECT_EQ(alarm->hour_, alarm1->hour_);
523         EXPECT_EQ(alarm->minute_, alarm1->minute_);
524         succeed = true;
525         break;
526     }
527     reminderStore.Delete(reminder->reminderId_);
528     EXPECT_EQ(succeed, true);
529     ClearStore();
530 }
531 
532 /**
533  * @tc.name: ReminderCalendarStrategyTest_00001
534  * @tc.desc: Test OnCreate parameters.
535  * @tc.type: FUNC
536  * @tc.require: issueI92BU9
537  */
538 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00001, Function | SmallTest | Level1)
539 {
540     ReminderStore reminderStore;
541     InitStore(reminderStore);
542     time_t t;
543     (void)time(&t);  // unit is seconds.
544     uint64_t ts = t * 1000;  // ms
545 
546     sptr<ReminderRequest> reminder = new ReminderRequestCalendar();
547     reminder->reminderId_ = 999;
548     reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
549     ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
550     calendar->firstDesignateYear_ = 2006;
551     calendar->firstDesignateMonth_ = 6;
552     calendar->firstDesignateDay_ = 6;
553     calendar->SetDateTime(ts);
554     calendar->SetEndDateTime(ts + 60 * 1000);
555     calendar->SetLastStartDateTime(ts + 10 * 1000);
556     calendar->repeatDay_ = 12;
557     calendar->repeatMonth_ = 13;
558     calendar->AddExcludeDate(ts);
559 
560     sptr<NotificationBundleOption> bundleOption = new NotificationBundleOption("test", 101);
561     reminderStore.UpdateOrInsert(reminder, bundleOption);
562     auto reminders = reminderStore.GetAllValidReminders();
563     bool succeed = false;
564     for (auto each : reminders) {
565         if (each->reminderId_ != reminder->reminderId_) {
566             continue;
567         }
568 
569         ReminderRequestCalendar* calendar1 = static_cast<ReminderRequestCalendar*>(each.GetRefPtr());
570         EXPECT_EQ(calendar1->firstDesignateYear_, calendar->firstDesignateYear_);
571         EXPECT_EQ(calendar1->firstDesignateMonth_, calendar->firstDesignateMonth_);
572         EXPECT_EQ(calendar1->firstDesignateDay_, calendar->firstDesignateDay_);
573         EXPECT_EQ(calendar1->repeatDay_, calendar->repeatDay_);
574         EXPECT_EQ(calendar1->repeatMonth_, calendar->repeatMonth_);
575         EXPECT_EQ(calendar1->GetDateTime(), calendar->GetDateTime());
576         EXPECT_EQ(calendar1->GetEndDateTime(), calendar->GetEndDateTime());
577         EXPECT_EQ(calendar1->GetLastStartDateTime(), calendar->GetLastStartDateTime());
578         EXPECT_EQ(calendar1->SerializationExcludeDates(), calendar->SerializationExcludeDates());
579         EXPECT_EQ(calendar1->SerializationRRule(), calendar->SerializationRRule());
580         succeed = true;
581         break;
582     }
583     reminderStore.Delete(reminder->reminderId_);
584     EXPECT_EQ(succeed, true);
585     ClearStore();
586 }
587 
588 /**
589  * @tc.name: ReminderCalendarStrategyTest_00002
590  * @tc.desc: Test OnCreate parameters.
591  * @tc.type: FUNC
592  * @tc.require: issueI92BU9
593  */
594 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00002, Function | SmallTest | Level1)
595 {
596     ReminderStore reminderStore;
597     InitStore(reminderStore);
598     time_t t;
599     (void)time(&t);  // unit is seconds.
600     uint64_t ts = t * 1000;  // ms
601 
602     sptr<ReminderRequest> reminder = new ReminderRequestCalendar();
603     reminder->reminderId_ = 999;
604     reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR;
605     reminder->repeatDaysOfWeek_ = 55;
606     ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
607     calendar->SetDateTime(ts);
608     calendar->rruleWantAgentInfo_ = std::make_shared<ReminderRequest::WantAgentInfo>();
609     calendar->rruleWantAgentInfo_->pkgName = "pkgName";
610     calendar->rruleWantAgentInfo_->abilityName = "abilityName";
611     calendar->rruleWantAgentInfo_->uri = "uri";
612 
613     sptr<NotificationBundleOption> bundleOption = new NotificationBundleOption("test", 101);
614     reminderStore.UpdateOrInsert(reminder, bundleOption);
615     auto reminders = reminderStore.GetAllValidReminders();
616     bool succeed = false;
617     for (auto each : reminders) {
618         if (each->reminderId_ != reminder->reminderId_) {
619             continue;
620         }
621 
622         EXPECT_EQ(reminder->repeatDaysOfWeek_, each->repeatDaysOfWeek_);
623         ReminderRequestCalendar* calendar1 = static_cast<ReminderRequestCalendar*>(each.GetRefPtr());
624         EXPECT_EQ(calendar1->GetDateTime(), calendar->GetDateTime());
625         EXPECT_EQ(calendar1->GetEndDateTime(), calendar->GetDateTime());
626         EXPECT_EQ(calendar1->GetLastStartDateTime(), calendar->GetDateTime());
627         EXPECT_EQ(calendar1->SerializationRRule(), calendar->SerializationRRule());
628         succeed = true;
629         break;
630     }
631     reminderStore.Delete(reminder->reminderId_);
632     EXPECT_EQ(succeed, true);
633     ClearStore();
634 }
635 }
636 }