1 /*
2  * Copyright (c) 2021-2023 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_request_calendar.h"
21 #include "reminder_table.h"
22 #undef private
23 #undef protected
24 
25 #include "ans_log_wrapper.h"
26 #include "reminder_helper.h"
27 
28 using namespace testing::ext;
29 namespace OHOS {
30 namespace Notification {
31 class ReminderRequestCalendarTest : public testing::Test {
32 public:
SetUpTestCase()33     static void SetUpTestCase()
34     {
35         ReminderHelper::CancelAllReminders();
36     }
SetUp()37     void SetUp() {}
TearDownTestCase()38     static void TearDownTestCase() {}
TearDown()39     void TearDown()
40     {
41         ReminderHelper::CancelAllReminders();
42     }
43 
CreateCalendar(tm & nowTime)44     std::shared_ptr<ReminderRequestCalendar> CreateCalendar(tm &nowTime)
45     {
46         time_t now;
47         (void)time(&now);  // unit is seconds.
48         tm *tmp = localtime(&now);
49         if (tmp == nullptr) {
50             return nullptr;
51         }
52         nowTime = *tmp;
53         nowTime.tm_year = 0;
54         nowTime.tm_mon = 0;
55         nowTime.tm_mday = 1;
56         nowTime.tm_hour = 1;
57         nowTime.tm_min = 1;
58         std::vector<uint8_t> repeatMonths;
59         std::vector<uint8_t> repeatDays;
60         std::vector<uint8_t> daysOfWeek;
61         repeatMonths.push_back(1);
62         repeatDays.push_back(1);
63         daysOfWeek.push_back(1);
64         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
65         calendar->SetNextTriggerTime();
66         return calendar;
67     }
68 
IsVectorEqual(std::vector<uint8_t> & vectorA,std::vector<uint8_t> & vectorB)69     bool IsVectorEqual(std::vector<uint8_t> &vectorA, std::vector<uint8_t> &vectorB)
70     {
71         if (vectorA.size() != vectorB.size()) {
72             return false;
73         }
74         if (vectorA.size() == 0) {
75             return true;
76         }
77         auto vitA = vectorA.begin();
78         auto vitB = vectorB.begin();
79         while (vitA != vectorA.end()) {
80             if (*vitA != *vitB) {
81                 return false;
82             }
83             ++vitA;
84             ++vitB;
85         }
86         return true;
87     }
88 };
89 
90 /**
91  * @tc.name: initDateTime_00100
92  * @tc.desc: Check firstDesignateYear set successfully.
93  * @tc.type: FUNC
94  * @tc.require: SR000GN4CU AR000GNF1V
95  */
96 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00100, Function | SmallTest | Level1)
97 {
98     struct tm nowTime;
99     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
100     EXPECT_NE(nullptr, calendar);
101     int32_t firstDesignateYear = calendar->GetActualTime(ReminderRequest::TimeTransferType::YEAR, nowTime.tm_year);
102     EXPECT_TRUE(firstDesignateYear == calendar->GetFirstDesignateYear()) << "Set first designate year error.";
103 }
104 
105 /**
106  * @tc.name: initDateTime_00200
107  * @tc.desc: Check firstDesignateMonth set successfully.
108  * @tc.type: FUNC
109  * @tc.require: SR000GN4CU AR000GNF1V
110  */
111 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00200, Function | SmallTest | Level1)
112 {
113     struct tm nowTime;
114     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
115     EXPECT_NE(nullptr, calendar);
116     int firstDesignateMonth = calendar->GetActualTime(ReminderRequest::TimeTransferType::MONTH, nowTime.tm_mon);
117     EXPECT_TRUE(firstDesignateMonth == calendar->GetFirstDesignageMonth()) << "Set first designate month error.";
118 }
119 
120 /**
121  * @tc.name: initDateTime_00300
122  * @tc.desc: Check firstDesignateDay set successfully.
123  * @tc.type: FUNC
124  * @tc.require: SR000GN4CU AR000GNF1V
125  */
126 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00300, Function | SmallTest | Level1)
127 {
128     struct tm nowTime;
129     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
130     EXPECT_NE(nullptr, calendar);
131     int firstDesignateDay = nowTime.tm_mday;
132     EXPECT_TRUE(firstDesignateDay == calendar->GetFirstDesignateDay()) << "Set first designate day error.";
133 }
134 
135 /**
136  * @tc.name: initDateTime_00400
137  * @tc.desc: Check repeatMonth set with normal value successfully.
138  * @tc.type: FUNC
139  * @tc.require: SR000GN4CU AR000GNF1V
140  */
141 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00400, Function | SmallTest | Level1)
142 {
143     time_t now;
144     (void)time(&now);  // unit is seconds.
145     tm *tmp = localtime(&now);
146     EXPECT_NE(nullptr, tmp);
147     struct tm nowTime = *tmp;
148 
149     std::vector<uint8_t> repeatMonths;
150     std::vector<uint8_t> repeatDays;
151     std::vector<uint8_t> daysOfWeek;
152     daysOfWeek.push_back(1);
153     repeatMonths.push_back(1);
154     repeatDays.push_back(1);
155     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
156     calendar->SetNextTriggerTime();
157     std::vector<uint8_t> actualRepeatMonths = calendar->GetRepeatMonths();
158     EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatMonths, actualRepeatMonths))
159         << "Set repeat month with 1 error.";
160 
161     repeatMonths.clear();
162     repeatMonths.push_back(12);
163     calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
164     calendar->SetNextTriggerTime();
165     actualRepeatMonths = calendar->GetRepeatMonths();
166     EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatMonths, actualRepeatMonths))
167         << "Set repeat month with 12 error.";
168 
169     repeatMonths.clear();
170     for (uint8_t i = 1; i <= 12; i++) {
171         repeatMonths.push_back(i);
172     }
173     calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
174     calendar->SetNextTriggerTime();
175     actualRepeatMonths = calendar->GetRepeatMonths();
176     EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatMonths, actualRepeatMonths))
177         << "Set repeat month with 1~12 error.";
178 }
179 
180 /**
181  * @tc.name: initDateTime_00500
182  * @tc.desc: Check repeatMonth set with exception value successfully.
183  * @tc.type: FUNC
184  * @tc.require: SR000GN4CU AR000GNF1V
185  */
186 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00500, Function | SmallTest | Level1)
187 {
188     time_t now;
189     time(&now);  // unit is seconds.
190     tm *tmp = localtime(&now);
191     EXPECT_NE(nullptr, tmp);
192     tm nowTime = *tmp;
193     nowTime.tm_year += 1;
194     std::vector<uint8_t> repeatMonth;
195     std::vector<uint8_t> repeatDay;
196     std::vector<uint8_t> daysOfWeek;
197     daysOfWeek.push_back(1);
198     repeatMonth.push_back(-1);
199     repeatDay.push_back(1);
200     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonth, repeatDay, daysOfWeek);
201     calendar->SetNextTriggerTime();
202     std::vector<uint8_t> actualRepeatMonths = calendar->GetRepeatMonths();
203     EXPECT_TRUE(actualRepeatMonths.size() == 0) << "Set repeat month with -1 error.";
204 
205     repeatMonth.clear();
206     repeatMonth.push_back(13);
207     calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonth, repeatDay, daysOfWeek);
208     calendar->SetNextTriggerTime();
209     actualRepeatMonths = calendar->GetRepeatMonths();
210     EXPECT_TRUE(actualRepeatMonths.size() == 0) << "Set repeat month with 13 error.";
211 }
212 
213 namespace {
214     bool g_mockNowInstantMilliRet = true;
215     uint64_t g_mockNumber = 1675876480000;
216 }
217 
MockNowInstantMilli(bool mockRet)218 void MockNowInstantMilli(bool mockRet)
219 {
220     g_mockNowInstantMilliRet = mockRet;
221 }
222 
GetNowInstantMilli() const223 uint64_t ReminderRequest::GetNowInstantMilli() const
224 {
225     if (g_mockNowInstantMilliRet == false) {
226         return 0;
227     }
228     return g_mockNumber;
229 }
230 
231 /**
232  * @tc.name: initDateTime_00600
233  * @tc.desc: Check repeatDay set with nomal value successfully.
234  * @tc.type: FUNC
235  * @tc.require: SR000GN4CU AR000GNF1V
236  */
237 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00600, Function | SmallTest | Level1)
238 {
239     time_t now;
240     (void)time(&now);  // unit is seconds.
241     tm *tmp = localtime(&now);
242     EXPECT_NE(nullptr, tmp);
243     tm nowTime = *tmp;
244     std::vector<uint8_t> repeatMonths;
245     std::vector<uint8_t> repeatDays;
246     std::vector<uint8_t> daysOfWeek;
247     daysOfWeek.push_back(1);
248     repeatMonths.push_back(1);
249     repeatDays.push_back(1);
250     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
251     calendar->SetNextTriggerTime();
252     std::vector<uint8_t> actualRepeatDays = calendar->GetRepeatDays();
253     EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatDays, actualRepeatDays))
254         << "Set repeat day with 1 error.";
255 
256     repeatDays.clear();
257     repeatDays.push_back(31);
258     calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
259     calendar->SetNextTriggerTime();
260     actualRepeatDays = calendar->GetRepeatDays();
261     EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatDays, actualRepeatDays))
262         << "Set repeat day with 31 error.";
263 
264     repeatDays.clear();
265     for (uint8_t i = 1; i <= 31; i++) {
266         repeatDays.push_back(i);
267     }
268     calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
269     calendar->SetNextTriggerTime();
270     actualRepeatDays = calendar->GetRepeatDays();
271     EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatDays, actualRepeatDays))
272         << "Set repeat day with 1~31 error.";
273 }
274 
275 /**
276  * @tc.name: initDateTime_00700
277  * @tc.desc: Check repeatDay set with exception value successfully.
278  * @tc.type: FUNC
279  * @tc.require: SR000GN4CU AR000GNF1V
280  */
281 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00700, Function | SmallTest | Level1)
282 {
283     time_t now;
284     (void)time(&now);  // unit is seconds.
285     tm *tmp = localtime(&now);
286     EXPECT_NE(nullptr, tmp);
287     tm nowTime = *tmp;
288     nowTime.tm_year += 1;
289     std::vector<uint8_t> repeatMonths;
290     std::vector<uint8_t> repeatDays;
291     std::vector<uint8_t> daysOfWeek;
292     daysOfWeek.push_back(-1);
293     repeatMonths.push_back(-1);
294     repeatDays.push_back(-1);
295     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
296     calendar->SetNextTriggerTime();
297     std::vector<uint8_t> actualRepeatDays = calendar->GetRepeatDays();
298     EXPECT_TRUE(actualRepeatDays.size() == 0) << "Set repeat day with -1 error.";
299 
300     repeatDays.clear();
301     repeatDays.push_back(32);
302     calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
303     calendar->SetNextTriggerTime();
304     actualRepeatDays = calendar->GetRepeatDays();
305     EXPECT_TRUE(actualRepeatDays.size() == 0) << "Set repeat day with 32 error.";
306 }
307 
308 /**
309  * @tc.name: initDateTime_00800
310  * @tc.desc: Check hour set successfully.
311  * @tc.type: FUNC
312  * @tc.require: SR000GN4CU AR000GNF1V
313  */
314 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00800, Function | SmallTest | Level1)
315 {
316     struct tm nowTime;
317     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
318     EXPECT_NE(nullptr, calendar);
319     EXPECT_TRUE(1 == calendar->GetHour()) << "Set hour error.";
320 }
321 
322 /**
323  * @tc.name: initDateTime_00900
324  * @tc.desc: Check minut set successfully.
325  * @tc.type: FUNC
326  * @tc.require: SR000GN4CU AR000GNF1V
327  */
328 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00900, Function | SmallTest | Level1)
329 {
330     struct tm nowTime;
331     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
332     EXPECT_NE(nullptr, calendar);
333     EXPECT_TRUE(1 == calendar->GetMinute()) << "Set minute error.";
334     EXPECT_TRUE(0 == calendar->GetSecond()) << "Set seconds error.";
335 }
336 
337 /**
338  * @tc.name: initDateTime_01000
339  * @tc.desc: Test InitDateTime parameters.
340  * @tc.type: FUNC
341  * @tc.require: issue
342  */
343 HWTEST_F(ReminderRequestCalendarTest, initDateTime_01000, Function | SmallTest | Level1)
344 {
345     struct tm nowTime;
346     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
347     EXPECT_NE(nullptr, calendar);
348     calendar->InitDateTime();
349     EXPECT_EQ(calendar->IsRepeatReminder(), true);
350 }
351 
352 /**
353  * @tc.name: OnDateTimeChange_01000
354  * @tc.desc: Test OnDateTimeChange parameters.
355  * @tc.type: FUNC
356  * @tc.require: issue
357  */
358 HWTEST_F(ReminderRequestCalendarTest, OnDateTimeChange_01000, Function | SmallTest | Level1)
359 {
360     struct tm nowTime;
361     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
362     EXPECT_NE(nullptr, calendar);
363     EXPECT_EQ(calendar->OnDateTimeChange(), false);
364 }
365 
366 /**
367  * @tc.name: OnTimeZoneChange_01000
368  * @tc.desc: Test OnTimeZoneChange parameters.
369  * @tc.type: FUNC
370  * @tc.require: issue
371  */
372 HWTEST_F(ReminderRequestCalendarTest, OnTimeZoneChange_01000, Function | SmallTest | Level1)
373 {
374     struct tm nowTime;
375     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
376     EXPECT_NE(nullptr, calendar);
377     EXPECT_EQ(calendar->OnTimeZoneChange(), false);
378 }
379 
380 /**
381  * @tc.name: UpdateNextReminder_01000
382  * @tc.desc: Test UpdateNextReminder parameters.
383  * @tc.type: FUNC
384  * @tc.require: issue
385  */
386 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_01000, Function | SmallTest | Level1)
387 {
388     struct tm nowTime;
389     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
390     EXPECT_NE(nullptr, calendar);
391     EXPECT_EQ(calendar->UpdateNextReminder(), true);
392 }
393 
394 /**
395  * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_01000
396  * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters.
397  * @tc.type: FUNC
398  * @tc.require: issue
399  */
400 HWTEST_F(ReminderRequestCalendarTest, PreGetNextTriggerTimeIgnoreSnooze_01000, Function | SmallTest | Level1)
401 {
402     bool ignoreRepeat = true;
403     bool forceToGetNext = true;
404     struct tm nowTime;
405     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
406     EXPECT_NE(nullptr, calendar);
407     EXPECT_EQ(calendar->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext),
408     calendar->GetNextTriggerTime());
409 }
410 
411 /**
412  * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_03000
413  * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters.
414  * @tc.type: FUNC
415  * @tc.require: issue
416  */
417 HWTEST_F(ReminderRequestCalendarTest, PreGetNextTriggerTimeIgnoreSnooze_03000, Function | SmallTest | Level1)
418 {
419     bool ignoreRepeat = false;
420     bool forceToGetNext = true;
421     struct tm nowTime;
422     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
423     EXPECT_NE(nullptr, calendar);
424 
425     EXPECT_EQ(calendar->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext),
426     calendar->GetNextTriggerTime());
427 }
428 
429 /**
430  * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_02000
431  * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters.
432  * @tc.type: FUNC
433  * @tc.require: issue
434  */
435 HWTEST_F(ReminderRequestCalendarTest, PreGetNextTriggerTimeIgnoreSnooze_02000, Function | SmallTest | Level1)
436 {
437     bool ignoreRepeat = false;
438     bool forceToGetNext = true;
439     time_t now;
440     time(&now);  // unit is seconds.
441     tm *tmp = localtime(&now);
442     EXPECT_NE(nullptr, tmp);
443     tm nowTime = *tmp;
444     nowTime.tm_year += 1;
445     std::vector<uint8_t> repeatMonths;
446     std::vector<uint8_t> repeatDays;
447     std::vector<uint8_t> daysOfWeek;
448     daysOfWeek.push_back(-1);
449     repeatMonths.push_back(-1);
450     repeatDays.push_back(-1);
451     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
452     EXPECT_EQ(calendar->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext), 0);
453 }
454 
455 /**
456  * @tc.name: Marshalling_00001
457  * @tc.desc: Test Marshalling parameters.
458  * @tc.type: FUNC
459  * @tc.require: issue
460  */
461 HWTEST_F(ReminderRequestCalendarTest, Marshalling_00001, Function | SmallTest | Level1)
462 {
463     Parcel parcel;
464     struct tm nowTime;
465     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
466     EXPECT_NE(nullptr, calendar);
467     EXPECT_EQ(calendar->Marshalling(parcel), true);
468 }
469 
470 /**
471  * @tc.name: Unmarshalling_00001
472  * @tc.desc: Test Unmarshalling parameters.
473  * @tc.type: FUNC
474  * @tc.require: issue
475  */
476 HWTEST_F(ReminderRequestCalendarTest, Unmarshalling_001, Function | SmallTest | Level1)
477 {
478     bool unmarshalling = true;
479     Parcel parcel;
480     struct tm nowTime;
481     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
482     EXPECT_NE(nullptr, calendar);
483     if (nullptr != calendar) {
484         if (nullptr == calendar->Unmarshalling(parcel)) {
485             unmarshalling = false;
486         }
487     }
488     EXPECT_EQ(unmarshalling, false);
489 }
490 
491 /**
492  * @tc.name: ReadFromParcel_00001
493  * @tc.desc: Test ReadFromParcel parameters.
494  * @tc.type: FUNC
495  * @tc.require: issueI
496  */
497 HWTEST_F(ReminderRequestCalendarTest, ReadFromParcel_00001, Function | SmallTest | Level1)
498 {
499     Parcel parcel;
500     struct tm nowTime;
501     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
502     EXPECT_NE(nullptr, calendar);
503     EXPECT_EQ(calendar->ReadFromParcel(parcel), false);
504 }
505 
506 /**
507  * @tc.name: GetDaysOfMonth_00001
508  * @tc.desc: Test GetDaysOfMonth parameters.
509  * @tc.type: FUNC
510  * @tc.require: issue
511  */
512 HWTEST_F(ReminderRequestCalendarTest, GetDaysOfMonth_00001, Function | SmallTest | Level1)
513 {
514     struct tm nowTime;
515     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
516     EXPECT_NE(nullptr, calendar);
517 
518     uint16_t year = 1;
519     uint8_t month = 2;
520     uint8_t result = calendar->GetDaysOfMonth(year, month);
521     uint8_t ret = 28;
522     EXPECT_EQ(result, ret);
523 }
524 
525 /**
526  * @tc.name: SetDay_00001
527  * @tc.desc: Test SetDay parameters.
528  * @tc.type: FUNC
529  * @tc.require: issue
530  */
531 HWTEST_F(ReminderRequestCalendarTest, SetDay_00001, Function | SmallTest | Level1)
532 {
533     struct tm nowTime;
534     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
535     EXPECT_NE(nullptr, calendar);
536 
537     uint8_t day = -1;
538     bool isSet = false;
539     calendar->SetDay(day, isSet);
540     bool result = calendar->IsRepeatDay(day);
541     EXPECT_EQ(result, false);
542 }
543 
544 /**
545  * @tc.name: SetDay_00002
546  * @tc.desc: Test SetDay parameters.
547  * @tc.type: FUNC
548  * @tc.require: issue
549  */
550 HWTEST_F(ReminderRequestCalendarTest, SetDay_00002, Function | SmallTest | Level1)
551 {
552     struct tm nowTime;
553     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
554     EXPECT_NE(nullptr, calendar);
555 
556     uint8_t day = 32;
557     bool isSet = false;
558     calendar->SetDay(day, isSet);
559     bool result = calendar->IsRepeatDay(day);
560     EXPECT_EQ(result, false);
561 }
562 
563 /**
564  * @tc.name: SetMonth_00001
565  * @tc.desc: Test SetMonth parameters.
566  * @tc.type: FUNC
567  * @tc.require: issue
568  */
569 HWTEST_F(ReminderRequestCalendarTest, SetMonth_00001, Function | SmallTest | Level1)
570 {
571     struct tm nowTime;
572     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
573     EXPECT_NE(nullptr, calendar);
574 
575     uint8_t month = -1;
576     bool isSet = false;
577     calendar->SetMonth(month, isSet);
578     bool result = calendar->IsRepeatMonth(month);
579     EXPECT_EQ(result, false);
580 }
581 
582 /**
583  * @tc.name: SetMonth_00002
584  * @tc.desc: Test SetMonth parameters.
585  * @tc.type: FUNC
586  * @tc.require: issue
587  */
588 HWTEST_F(ReminderRequestCalendarTest, SetMonth_00002, Function | SmallTest | Level1)
589 {
590     struct tm nowTime;
591     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
592     EXPECT_NE(nullptr, calendar);
593 
594     uint8_t month = 13;
595     bool isSet = false;
596     calendar->SetMonth(month, isSet);
597     bool result = calendar->IsRepeatMonth(month);
598     EXPECT_EQ(result, false);
599 }
600 
601 /**
602  * @tc.name: SetRepeatDaysOfMonth_00001
603  * @tc.desc: Test SetRepeatDaysOfMonth parameters.
604  * @tc.type: FUNC
605  * @tc.require: issue
606  */
607 HWTEST_F(ReminderRequestCalendarTest, SetRepeatDaysOfMonth_00001, Function | SmallTest | Level1)
608 {
609     struct tm nowTime;
610     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
611     EXPECT_NE(nullptr, calendar);
612 
613     std::vector<uint8_t> repeatDays;
614     repeatDays.emplace_back(1);
615     repeatDays.emplace_back(2);
616     repeatDays.emplace_back(3);
617     repeatDays.emplace_back(4);
618     repeatDays.emplace_back(5);
619     repeatDays.emplace_back(6);
620     repeatDays.emplace_back(7);
621     repeatDays.emplace_back(8);
622     repeatDays.emplace_back(9);
623     repeatDays.emplace_back(10);
624     repeatDays.emplace_back(11);
625     repeatDays.emplace_back(12);
626     repeatDays.emplace_back(13);
627     repeatDays.emplace_back(14);
628     repeatDays.emplace_back(15);
629     repeatDays.emplace_back(16);
630     repeatDays.emplace_back(17);
631     repeatDays.emplace_back(18);
632     repeatDays.emplace_back(19);
633     repeatDays.emplace_back(20);
634     repeatDays.emplace_back(21);
635     repeatDays.emplace_back(22);
636     repeatDays.emplace_back(23);
637     repeatDays.emplace_back(24);
638     repeatDays.emplace_back(25);
639     repeatDays.emplace_back(26);
640     repeatDays.emplace_back(27);
641     repeatDays.emplace_back(28);
642     repeatDays.emplace_back(29);
643     repeatDays.emplace_back(30);
644     repeatDays.emplace_back(31);
645     repeatDays.emplace_back(32);
646     EXPECT_EQ(repeatDays.size(), 32);
647 
648     calendar->SetRepeatDaysOfMonth(repeatDays);
649     std::vector<uint8_t> result = calendar->GetRepeatMonths();
650     EXPECT_EQ(result.size(), 1);
651 }
652 
653 /**
654  * @tc.name: UpdateNextReminder_00001
655  * @tc.desc: Test UpdateNextReminder parameters.
656  * @tc.type: FUNC
657  * @tc.require: issue
658  */
659 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00001, Function | SmallTest | Level1)
660 {
661     struct tm nowTime;
662     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
663     EXPECT_NE(nullptr, calendar);
664 
665     uint8_t day = 1;
666     bool isSet = false;
667     calendar->SetDay(day, isSet);
668 
669     uint8_t month = 1;
670     calendar->SetMonth(month, isSet);
671 
672     std::vector<uint8_t> repeatDaysOfWeek;
673     repeatDaysOfWeek.push_back(1);
674     calendar->SetRepeatDaysOfWeek(isSet, repeatDaysOfWeek);
675 
676     auto rrc = std::make_shared<ReminderRequest>();
677     rrc->SetSnoozeTimes(0);
678     EXPECT_EQ(rrc->GetSnoozeTimes(), 0) << "Get snoozeTimes not 1";
679 
680     uint32_t minTimeIntervalInSecond = 0;
681     rrc->SetTimeInterval(0);
682     EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond);
683 
684     bool result2 = calendar->IsRepeatReminder();
685     EXPECT_EQ(result2, false);
686 
687     uint32_t ret = calendar->GetRepeatDay();
688     uint16_t ret2 = calendar->GetRepeatMonth();
689     uint8_t ret3 = calendar->GetRepeatMonth();
690     EXPECT_EQ(ret, 0);
691     EXPECT_EQ(ret2, 0);
692     EXPECT_EQ(ret3, 0);
693 
694     bool result3 = calendar->UpdateNextReminder();
695     EXPECT_EQ(result3, false);
696 }
697 
698 /**
699  * @tc.name: UpdateNextReminder_00002
700  * @tc.desc: Test UpdateNextReminder parameters.
701  * @tc.type: FUNC
702  * @tc.require: issue
703  */
704 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00002, Function | SmallTest | Level1)
705 {
706     struct tm nowTime;
707     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
708     EXPECT_NE(nullptr, calendar);
709 
710     uint8_t day = 2;
711     bool isSet = true;
712     calendar->SetDay(day, isSet);
713     bool result = calendar->IsRepeatDay(day);
714     EXPECT_EQ(result, true);
715 
716     uint8_t month = 2;
717     calendar->SetMonth(month, isSet);
718     bool result1 = calendar->IsRepeatMonth(month);
719     EXPECT_EQ(result1, true);
720 
721     bool result2 = calendar->IsRepeatReminder();
722     EXPECT_EQ(result2, true);
723 
724     auto rrc = std::make_shared<ReminderRequest>();
725     rrc->SetSnoozeTimes(1);
726     EXPECT_EQ(rrc->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1";
727     EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 1) << "Get snoozeTimesDynamic not 1";
728 
729     uint32_t minTimeIntervalInSecond = 5 * 60;
730     rrc->SetTimeInterval(1);
731     EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond);
732 
733     bool result3 = calendar->UpdateNextReminder();
734     EXPECT_EQ(result3, true);
735 }
736 
737 /**
738  * @tc.name: UpdateNextReminder_00003
739  * @tc.desc: Test UpdateNextReminder parameters.
740  * @tc.type: FUNC
741  * @tc.require: issue
742  */
743 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00003, Function | SmallTest | Level1)
744 {
745     struct tm nowTime;
746     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
747     EXPECT_NE(nullptr, calendar);
748 
749     uint8_t day = 1;
750     bool isSet = false;
751     calendar->SetDay(day, isSet);
752 
753     uint8_t month = 2;
754     bool isSet1 = true;
755     calendar->SetMonth(month, isSet1);
756 
757     std::vector<uint8_t> daysOfWeek;
758     daysOfWeek.push_back(1);
759     calendar->SetRepeatDaysOfWeek(isSet, daysOfWeek);
760 
761     auto rrc = std::make_shared<ReminderRequest>();
762     rrc->SetSnoozeTimesDynamic(0);
763     EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 0);
764 
765     rrc->SetSnoozeTimes(1);
766     EXPECT_EQ(rrc->GetSnoozeTimes(), 1);
767     uint32_t minTimeIntervalInSecond = 5 * 60;
768     rrc->SetTimeInterval(1);
769     EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond);
770 
771     uint32_t ret = calendar->GetRepeatDay();
772     uint16_t ret2 = calendar->GetRepeatMonth();
773     uint16_t ret3 = 3;
774     EXPECT_EQ(ret, 0);
775     EXPECT_EQ(ret2, ret3);
776 
777     bool result3 = calendar->UpdateNextReminder();
778     EXPECT_EQ(result3, false);
779 }
780 
781 /**
782  * @tc.name: UpdateNextReminder_00004
783  * @tc.desc: Test UpdateNextReminder parameters.
784  * @tc.type: FUNC
785  * @tc.require: issue
786  */
787 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00004, Function | SmallTest | Level1)
788 {
789     struct tm nowTime;
790     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
791     EXPECT_NE(nullptr, calendar);
792 
793     uint8_t day = 1;
794     bool isSet = false;
795     calendar->SetDay(day, isSet);
796     bool result = calendar->IsRepeatDay(day);
797     EXPECT_EQ(result, false);
798 
799     uint8_t month = 1;
800     calendar->SetMonth(month, isSet);
801     bool result7 = calendar->IsRepeatMonth(month);
802     EXPECT_EQ(result7, false);
803 
804     std::vector<uint8_t> daysOfWeek;
805     daysOfWeek.push_back(1);
806     calendar->SetRepeatDaysOfWeek(isSet, daysOfWeek);
807     bool result2 = calendar->IsRepeatDaysOfWeek(1);
808     EXPECT_EQ(result2, false);
809 
810     auto reminderRequest = std::make_shared<ReminderRequest>();
811     reminderRequest->SetSnoozeTimes(1);
812     EXPECT_EQ(reminderRequest->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1";
813 
814     reminderRequest->SetSnoozeTimesDynamic(0);
815     EXPECT_EQ(reminderRequest->GetSnoozeTimesDynamic(), 0) << "Get snoozeTimesDynamic not 1";
816 
817     uint32_t minTimeIntervalInSeconds = 5 * 60;
818     reminderRequest->SetTimeInterval(1);
819     EXPECT_EQ(reminderRequest->GetTimeInterval(), minTimeIntervalInSeconds);
820 
821     bool result6 = calendar->UpdateNextReminder();
822     EXPECT_EQ(result6, false);
823 }
824 
825 /**
826  * @tc.name: UpdateNextReminder_00005
827  * @tc.desc: Test UpdateNextReminder parameters.
828  * @tc.type: FUNC
829  * @tc.require: issue
830  */
831 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00005, Function | SmallTest | Level1)
832 {
833     struct tm nowTime;
834     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
835     EXPECT_NE(nullptr, calendar);
836 
837     uint8_t day = 2;
838     bool isSet = true;
839     calendar->SetDay(day, isSet);
840     bool result = calendar->IsRepeatDay(day);
841     EXPECT_EQ(result, true);
842 
843     uint8_t month = 1;
844     bool isSet1 = false;
845     calendar->SetMonth(month, isSet1);
846     bool result1 = calendar->IsRepeatMonth(month);
847     EXPECT_EQ(result1, false);
848 
849     std::vector<uint8_t> daysOfWeek;
850     daysOfWeek.push_back(1);
851     calendar->SetRepeatDaysOfWeek(isSet1, daysOfWeek);
852 
853     auto rrc = std::make_shared<ReminderRequest>();
854     rrc->SetSnoozeTimes(1);
855     EXPECT_EQ(rrc->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1";
856 
857     rrc->SetSnoozeTimesDynamic(0);
858     EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 0) << "Get snoozeTimesDynamic not 1";
859 
860     uint32_t minTimeIntervalInSecond = 5 * 60;
861     rrc->SetTimeInterval(1);
862     EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond);
863 
864     bool result3 = calendar->UpdateNextReminder();
865     EXPECT_EQ(result3, false);
866 }
867 
868 /**
869  * @tc.name: UpdateNextReminder_00006
870  * @tc.desc: Test UpdateNextReminder parameters.
871  * @tc.type: FUNC
872  * @tc.require: I8CZ6P
873  */
874 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00006, Function | SmallTest | Level1)
875 {
876     struct tm nowTime;
877     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
878     EXPECT_NE(nullptr, calendar);
879 
880     uint8_t day = 2;
881     bool isSet = false;
882     bool isSet1 = true;
883     calendar->SetDay(day, isSet);
884     bool result = calendar->IsRepeatDay(day);
885     EXPECT_EQ(result, false);
886 
887     uint8_t month = 2;
888     calendar->SetMonth(month, isSet);
889     bool result1 = calendar->IsRepeatMonth(month);
890     EXPECT_EQ(result1, false);
891 
892     std::vector<uint8_t> daysOfWeek;
893     daysOfWeek.push_back(1);
894     daysOfWeek.push_back(3);
895     daysOfWeek.push_back(4);
896     daysOfWeek.push_back(5);
897     daysOfWeek.push_back(6);
898     calendar->SetRepeatDaysOfWeek(isSet1, daysOfWeek);
899 
900     bool result2 = calendar->IsRepeatDaysOfWeek(1);
901     EXPECT_EQ(result2, true);
902 
903     bool result3 = calendar->IsRepeatReminder();
904     EXPECT_EQ(result3, true);
905 
906     auto rrc = std::make_shared<ReminderRequest>();
907     rrc->SetSnoozeTimes(1);
908     EXPECT_EQ(rrc->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1";
909     EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 1) << "Get snoozeTimesDynamic not 1";
910 
911     uint32_t minTimeIntervalInSecond = 5 * 60;
912     rrc->SetTimeInterval(1);
913     EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond);
914 
915     bool result4 = calendar->UpdateNextReminder();
916     EXPECT_EQ(result4, true);
917 
918     uint16_t ret2 = calendar->GetRepeatDaysOfWeek();
919     uint16_t ret3 = 61;
920     EXPECT_EQ(ret2, ret3);
921 }
922 
923 /**
924  * @tc.name: SetRepeatMonths_00001
925  * @tc.desc: Test SetRepeatMonths parameters.
926  * @tc.type: FUNC
927  * @tc.require: issue
928  */
929 HWTEST_F(ReminderRequestCalendarTest, SetRepeatMonths_00001, Function | SmallTest | Level1)
930 {
931     struct tm nowTime;
932     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
933     EXPECT_NE(nullptr, calendar);
934 
935     uint8_t arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
936     std::vector<uint8_t> repeatMonths (arr, arr + sizeof(arr) / sizeof(uint8_t));
937     calendar->SetRepeatMonths(repeatMonths);
938     uint8_t ret = 13;
939     EXPECT_EQ(repeatMonths.size(), ret);
940 }
941 
942 /**
943  * @tc.name: RecoverFromDb_00001
944  * @tc.desc: Test RecoverFromDb parameters.
945  * @tc.type: FUNC
946  * @tc.require: issue
947  */
948 HWTEST_F(ReminderRequestCalendarTest, RecoverFromDb_00001, Function | SmallTest | Level1)
949 {
950     struct tm nowTime;
951     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
952     EXPECT_NE(nullptr, calendar);
953 
954     bool result = calendar->IsRepeatDay(1);
955     EXPECT_EQ(result, true);
956 }
957 
958 /**
959  * @tc.name: InitTriggerTime_00001
960  * @tc.desc: Test InitTriggerTime parameters.
961  * @tc.type: FUNC
962  * @tc.require:I9BM6I
963  */
964 HWTEST_F(ReminderRequestCalendarTest, InitTriggerTime_00001, Function | SmallTest | Level1)
965 {
966     struct tm nowTime;
967     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
968     EXPECT_NE(nullptr, calendar);
969     EXPECT_EQ(calendar->InitTriggerTime(), true);
970 }
971 
972 
973 /**
974  * @tc.name: CheckCalenderIsExpired_00001
975  * @tc.desc: Test CheckCalenderIsExpired parameters.
976  * @tc.type: FUNC
977  * @tc.require:I9BM6I
978  */
979 HWTEST_F(ReminderRequestCalendarTest, CheckCalenderIsExpired_00001, Function | SmallTest | Level1)
980 {
981     auto rrc = std::make_shared<ReminderRequestCalendar>();
982     rrc->startDateTime_ = 1675876470000;
983     rrc->endDateTime_ = 1675876480005;
984     uint64_t now = 1675876480005;
985     EXPECT_EQ(rrc->CheckCalenderIsExpired(now), true);
986 }
987 
988 /**
989  * @tc.name: CheckCalenderIsExpired_00002
990  * @tc.desc: Test CheckCalenderIsExpired parameters.
991  * @tc.type: FUNC
992  * @tc.require:I9BM6I
993  */
994 HWTEST_F(ReminderRequestCalendarTest, CheckCalenderIsExpired_00002, Function | SmallTest | Level1)
995 {
996     auto rrc = std::make_shared<ReminderRequestCalendar>();
997     uint64_t now = 1675876480005;
998     EXPECT_EQ(rrc->CheckCalenderIsExpired(now), false);
999 }
1000 
1001 /**
1002  * @tc.name: CheckCalenderIsExpired_00003
1003  * @tc.desc: Test CheckCalenderIsExpired parameters.
1004  * @tc.type: FUNC
1005  * @tc.require:I9BM6I
1006  */
1007 HWTEST_F(ReminderRequestCalendarTest, CheckCalenderIsExpired_00003, Function | SmallTest | Level1)
1008 {
1009     time_t now;
1010     (void)time(&now);  // unit is seconds.
1011     struct tm nowTime;
1012     (void)localtime_r(&now, &nowTime);
1013     std::vector<uint8_t> repeatMonths;
1014     std::vector<uint8_t> repeatDays;
1015     std::vector<uint8_t> daysOfWeek;
1016     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1017     EXPECT_NE(nullptr, calendar);
1018 
1019     calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1020     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1021 
1022     EXPECT_EQ(calendar->IsInExcludeDate(), true);
1023     EXPECT_EQ(calendar->CheckCalenderIsExpired(static_cast<uint64_t>(now) * 1000), false);
1024 }
1025 
1026 /**
1027  * @tc.name: OnDateTimeChange_00001
1028  * @tc.desc: Test OnDateTimeChange parameters.
1029  * @tc.type: FUNC
1030  * @tc.require:I9BM6I
1031  */
1032 HWTEST_F(ReminderRequestCalendarTest, OnDateTimeChange_00001, Function | SmallTest | Level1)
1033 {
1034     auto rrc = std::make_shared<ReminderRequestCalendar>();
1035     EXPECT_NE(rrc, nullptr);
1036     rrc->SetExpired(true);
1037     EXPECT_EQ(rrc->OnDateTimeChange(), false);
1038 }
1039 
1040 /**
1041  * @tc.name: OnDateTimeChange_00002
1042  * @tc.desc: Test OnDateTimeChange parameters.
1043  * @tc.type: FUNC
1044  * @tc.require:I9BM6I
1045  */
1046 HWTEST_F(ReminderRequestCalendarTest, OnDateTimeChange_00002, Function | SmallTest | Level1)
1047 {
1048     auto rrc = std::make_shared<ReminderRequestCalendar>();
1049     EXPECT_NE(rrc, nullptr);
1050     rrc->SetExpired(false);
1051     EXPECT_EQ(rrc->OnDateTimeChange(), false);
1052 }
1053 
1054 /**
1055  * @tc.name: OnDateTimeChange_00003
1056  * @tc.desc: Test OnDateTimeChange parameters.
1057  * @tc.type: FUNC
1058  * @tc.require:I9BM6I
1059  */
1060 HWTEST_F(ReminderRequestCalendarTest, OnDateTimeChange_00003, Function | SmallTest | Level1)
1061 {
1062     auto rrc = std::make_shared<ReminderRequestCalendar>();
1063     EXPECT_NE(rrc, nullptr);
1064     rrc->SetExpired(false);
1065     rrc->startDateTime_ = 1675876470000;
1066     rrc->endDateTime_ = 1901086458000;
1067     EXPECT_EQ(rrc->OnDateTimeChange(), true);
1068 }
1069 
1070 /**
1071  * @tc.name: RecoverFromDb_00001
1072  * @tc.desc: Test RecoverFromDb parameters.
1073  * @tc.type: FUNC
1074  * @tc.require: I92G9T
1075  */
1076 HWTEST_F(ReminderRequestCalendarTest, RRuleWantAgentInfo_00001, Function | SmallTest | Level1)
1077 {
1078     struct tm nowTime;
1079     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1080     auto wantInfo = std::make_shared<ReminderRequest::WantAgentInfo>();
1081     wantInfo->pkgName = "testing service";
1082     wantInfo->abilityName = "testing ability";
1083     calendar->SetRRuleWantAgentInfo(wantInfo);
1084     EXPECT_EQ(calendar->GetRRuleWantAgentInfo(), wantInfo);
1085 }
1086 
1087 /**
1088  * @tc.name: RecoverFromOldVersion_00001
1089  * @tc.desc: Test RecoverFromOldVersion parameters.
1090  * @tc.type: FUNC
1091  * @tc.require: issueI92BU9
1092  */
1093 HWTEST_F(ReminderRequestCalendarTest, RecoverFromOldVersion_00001, Function | SmallTest | Level1)
1094 {
1095     struct tm nowTime;
1096     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1097     EXPECT_NE(nullptr, calendar);
1098 
1099     bool result = calendar->IsRepeatDay(1);
1100     EXPECT_EQ(result, true);
1101 }
1102 
1103 /**
1104  * @tc.name: SetDateTime_00001
1105  * @tc.desc: Test SetDateTime parameters.
1106  * @tc.type: FUNC
1107  * @tc.require: issueI92BU9
1108  */
1109 HWTEST_F(ReminderRequestCalendarTest, SetDateTime_00001, Function | SmallTest | Level1)
1110 {
1111     struct tm nowTime;
1112     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1113     EXPECT_NE(nullptr, calendar);
1114     calendar->SetDateTime(0);
1115     EXPECT_EQ(calendar->GetDateTime(), 0);
1116 }
1117 
1118 /**
1119  * @tc.name: SetEndDateTime_00001
1120  * @tc.desc: Test SetEndDateTime parameters.
1121  * @tc.type: FUNC
1122  * @tc.require: I9BM6I
1123  */
1124 HWTEST_F(ReminderRequestCalendarTest, SetEndDateTime_00001, Function | SmallTest | Level1)
1125 {
1126     struct tm nowTime;
1127     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1128     EXPECT_NE(nullptr, calendar);
1129     EXPECT_EQ(calendar->SetEndDateTime(0), false);
1130     EXPECT_NE(calendar->GetEndDateTime(), 0);
1131 }
1132 
1133 /**
1134  * @tc.name: SetEndDateTime_00002
1135  * @tc.desc: Test SetEndDateTime parameters.
1136  * @tc.type: FUNC
1137  * @tc.require: I9BM6I
1138  */
1139 HWTEST_F(ReminderRequestCalendarTest, SetEndDateTime_00002, Function | SmallTest | Level1)
1140 {
1141     struct tm nowTime;
1142     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1143     EXPECT_NE(nullptr, calendar);
1144     calendar->startDateTime_ = 5;
1145     EXPECT_EQ(calendar->SetEndDateTime(0), false);
1146     EXPECT_NE(calendar->GetEndDateTime(), 0);
1147 }
1148 
1149 /**
1150  * @tc.name: SerializationRRule_00001
1151  * @tc.desc: Test SerializationRRule parameters.
1152  * @tc.type: FUNC
1153  * @tc.require: issueI92BU9
1154  */
1155 HWTEST_F(ReminderRequestCalendarTest, SerializationRRule_00001, Function | SmallTest | Level1)
1156 {
1157     struct tm nowTime;
1158     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1159     EXPECT_NE(nullptr, calendar);
1160     std::string result = calendar->SerializationRRule();
1161     EXPECT_EQ(result.size(), 0);
1162 }
1163 
1164 /**
1165  * @tc.name: SerializationRRule_00002
1166  * @tc.desc: Test SerializationRRule parameters.
1167  * @tc.type: FUNC
1168  * @tc.require: issueI92BU9
1169  */
1170 HWTEST_F(ReminderRequestCalendarTest, SerializationRRule_00002, Function | SmallTest | Level1)
1171 {
1172     struct tm nowTime;
1173     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1174     EXPECT_NE(nullptr, calendar);
1175     calendar->rruleWantAgentInfo_ = std::make_shared<ReminderRequest::WantAgentInfo>();
1176     calendar->rruleWantAgentInfo_->pkgName = "com.example.myapplication";
1177     calendar->rruleWantAgentInfo_->abilityName = "MainAbility";
1178     calendar->rruleWantAgentInfo_->uri = "test";
1179     std::string result = calendar->SerializationRRule();
1180     EXPECT_NE(result.find("com.example.myapplication"), std::string::npos);
1181     EXPECT_NE(result.find("MainAbility"), std::string::npos);
1182     EXPECT_NE(result.find("test"), std::string::npos);
1183 }
1184 
1185 /**
1186  * @tc.name: DeserializationRRule_00001
1187  * @tc.desc: Test DeserializationRRule parameters.
1188  * @tc.type: FUNC
1189  * @tc.require: issueI92BU9
1190  */
1191 HWTEST_F(ReminderRequestCalendarTest, DeserializationRRule_00001, Function | SmallTest | Level1)
1192 {
1193     struct tm nowTime;
1194     auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime);
1195     EXPECT_NE(nullptr, calendar);
1196     std::string str;
1197     calendar->DeserializationRRule(str);
1198     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1199 
1200     str = "asdfwsbsdf";
1201     calendar->DeserializationRRule(str);
1202     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1203 
1204     // pkgName
1205     str = "{}";
1206     calendar->DeserializationRRule(str);
1207     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1208 
1209     str = R"({"pkgName":1})";
1210     calendar->DeserializationRRule(str);
1211     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1212 
1213     // abilityName
1214     str = R"({"pkgName":"com.example.myapplication"})";
1215     calendar->DeserializationRRule(str);
1216     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1217 
1218     str = R"({"pkgName":"com.example.myapplication","abilityName":1})";
1219     calendar->DeserializationRRule(str);
1220     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1221 
1222     // uri
1223     str = R"({"pkgName":"com.example.myapplication","abilityName":"MainAbility"})";
1224     calendar->DeserializationRRule(str);
1225     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1226 
1227     str = R"({"pkgName":"com.example.myapplication","abilityName":"MainAbility","uri":1})";
1228     calendar->DeserializationRRule(str);
1229     EXPECT_EQ(calendar->rruleWantAgentInfo_, nullptr);
1230 
1231     str = R"({"pkgName":"com.example.myapplication","abilityName":"MainAbility","uri":"uri"})";
1232     calendar->DeserializationRRule(str);
1233     EXPECT_EQ(calendar->rruleWantAgentInfo_->pkgName, "com.example.myapplication");
1234     EXPECT_EQ(calendar->rruleWantAgentInfo_->abilityName, "MainAbility");
1235     EXPECT_EQ(calendar->rruleWantAgentInfo_->uri, "uri");
1236 }
1237 
1238 /**
1239  * @tc.name: ExcludeDate_00001
1240  * @tc.desc: Test InitTriggerTime parameters.
1241  * @tc.type: FUNC
1242  * @tc.require: issue#I9F24R
1243  */
1244 HWTEST_F(ReminderRequestCalendarTest, ExcludeDate_00001, Function | SmallTest | Level1)
1245 {
1246     time_t now;
1247     (void)time(&now);  // unit is seconds.
1248     struct tm nowTime;
1249     (void)localtime_r(&now, &nowTime);
1250     std::vector<uint8_t> repeatMonths;
1251     std::vector<uint8_t> repeatDays;
1252     std::vector<uint8_t> daysOfWeek;
1253     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1254     EXPECT_NE(nullptr, calendar);
1255 
1256     calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1257     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1258 
1259     calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1260     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1261 
1262     calendar->AddExcludeDate((static_cast<uint64_t>(now) + 24 * 60 * 60) * 1000);
1263     EXPECT_EQ(calendar->excludeDates_.size(), 2);
1264 
1265     auto dates = calendar->GetExcludeDates();
1266     EXPECT_EQ(dates.size(), 2);
1267 
1268     calendar->DelExcludeDates();
1269     EXPECT_EQ(calendar->excludeDates_.size(), 0);
1270     dates = calendar->GetExcludeDates();
1271     EXPECT_EQ(dates.size(), 0);
1272 }
1273 
1274 /**
1275  * @tc.name: IsInExcludeDate_00002
1276  * @tc.desc: Test IsInExcludeDate.
1277  * @tc.type: FUNC
1278  * @tc.require: issue#I9F24R
1279  */
1280 HWTEST_F(ReminderRequestCalendarTest, IsInExcludeDate_00001, Function | SmallTest | Level1)
1281 {
1282     time_t now;
1283     (void)time(&now);  // unit is seconds.
1284     struct tm nowTime;
1285     (void)localtime_r(&now, &nowTime);
1286     std::vector<uint8_t> repeatMonths;
1287     std::vector<uint8_t> repeatDays;
1288     std::vector<uint8_t> daysOfWeek;
1289     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1290     EXPECT_NE(nullptr, calendar);
1291 
1292     calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1293     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1294 
1295     EXPECT_EQ(calendar->IsInExcludeDate(), true);
1296 
1297     calendar->DelExcludeDates();
1298     calendar->AddExcludeDate((static_cast<uint64_t>(now) + 24 * 60 * 60) * 1000);
1299     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1300     EXPECT_EQ(calendar->IsInExcludeDate(), false);
1301 }
1302 
1303 /**
1304  * @tc.name: IsRepeat_00001
1305  * @tc.desc: Test IsRepeat parameters.
1306  * @tc.type: FUNC
1307  * @tc.require: issue#I9F24R
1308  */
1309 HWTEST_F(ReminderRequestCalendarTest, IsRepeat_00001, Function | SmallTest | Level1)
1310 {
1311     time_t now;
1312     (void)time(&now);  // unit is seconds.
1313     struct tm nowTime;
1314     (void)localtime_r(&now, &nowTime);
1315 
1316     {
1317         std::vector<uint8_t> repeatMonths;
1318         std::vector<uint8_t> repeatDays;
1319         std::vector<uint8_t> daysOfWeek;
1320         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1321         EXPECT_NE(nullptr, calendar);
1322         EXPECT_EQ(calendar->IsRepeat(), false);
1323     }
1324 
1325     {
1326         std::vector<uint8_t> repeatMonths{ 1 };
1327         std::vector<uint8_t> repeatDays{ 1 };
1328         std::vector<uint8_t> daysOfWeek;
1329         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1330         EXPECT_NE(nullptr, calendar);
1331         EXPECT_EQ(calendar->IsRepeat(), true);
1332     }
1333 
1334     {
1335         std::vector<uint8_t> repeatMonths{ 1 };
1336         std::vector<uint8_t> repeatDays{ 1 };
1337         std::vector<uint8_t> daysOfWeek;
1338         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1339         EXPECT_NE(nullptr, calendar);
1340         EXPECT_EQ(calendar->IsRepeat(), true);
1341     }
1342 
1343     {
1344         std::vector<uint8_t> repeatMonths;
1345         std::vector<uint8_t> repeatDays;
1346         std::vector<uint8_t> daysOfWeek{ 1 };
1347         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1348         EXPECT_NE(nullptr, calendar);
1349         EXPECT_EQ(calendar->IsRepeat(), true);
1350     }
1351 }
1352 
1353 /**
1354  * @tc.name: CheckExcludeDate_00001
1355  * @tc.desc: Test CheckExcludeDate parameters.
1356  * @tc.type: FUNC
1357  * @tc.require: issue#I9F24R
1358  */
1359 HWTEST_F(ReminderRequestCalendarTest, CheckExcludeDate_00001, Function | SmallTest | Level1)
1360 {
1361     time_t now;
1362     (void)time(&now);  // unit is seconds.
1363     struct tm nowTime;
1364     (void)localtime_r(&now, &nowTime);
1365 
1366     {
1367         std::vector<uint8_t> repeatMonths;
1368         std::vector<uint8_t> repeatDays;
1369         std::vector<uint8_t> daysOfWeek;
1370         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1371         EXPECT_NE(nullptr, calendar);
1372         EXPECT_EQ(calendar->IsRepeat(), false);
1373         EXPECT_EQ(calendar->CheckExcludeDate(), false);
1374     }
1375 
1376     {
1377         std::vector<uint8_t> repeatMonths;
1378         std::vector<uint8_t> repeatDays;
1379         std::vector<uint8_t> daysOfWeek{ 1, 2, 3, 4, 5, 6, 7};
1380         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1381         EXPECT_NE(nullptr, calendar);
1382         EXPECT_EQ(calendar->IsRepeat(), true);
1383         EXPECT_EQ(calendar->CheckExcludeDate(), false);
1384     }
1385 
1386     {
1387         std::vector<uint8_t> repeatMonths;
1388         std::vector<uint8_t> repeatDays;
1389         std::vector<uint8_t> daysOfWeek{ 1, 2, 3, 4, 5, 6, 7};
1390         auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1391         calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1392         EXPECT_NE(nullptr, calendar);
1393         EXPECT_EQ(calendar->IsRepeat(), true);
1394         EXPECT_EQ(calendar->CheckExcludeDate(), true);
1395     }
1396 }
1397 
1398 /**
1399  * @tc.name: SerializationExcludeDates_00001
1400  * @tc.desc: Test SerializationExcludeDates parameters.
1401  * @tc.type: FUNC
1402  * @tc.require: issue#I9F24R
1403  */
1404 HWTEST_F(ReminderRequestCalendarTest, SerializationExcludeDates_00001, Function | SmallTest | Level1)
1405 {
1406     time_t now;
1407     (void)time(&now);  // unit is seconds.
1408     struct tm nowTime;
1409     (void)localtime_r(&now, &nowTime);
1410 
1411     std::vector<uint8_t> repeatMonths;
1412     std::vector<uint8_t> repeatDays;
1413     std::vector<uint8_t> daysOfWeek;
1414     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1415     EXPECT_NE(nullptr, calendar);
1416 
1417     std::string str = calendar->SerializationExcludeDates();
1418     EXPECT_NE(str.find("[]"), std::string::npos);
1419 
1420     calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1421     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1422 
1423     uint64_t date = *calendar->excludeDates_.begin();
1424     str = calendar->SerializationExcludeDates();
1425     EXPECT_NE(str.find(std::to_string(date)), std::string::npos);
1426 }
1427 
1428 /**
1429  * @tc.name: DeserializationExcludeDates_00001
1430  * @tc.desc: Test DeserializationExcludeDates parameters.
1431  * @tc.type: FUNC
1432  * @tc.require: issue#I9F24R
1433  */
1434 HWTEST_F(ReminderRequestCalendarTest, DeserializationExcludeDates_00001, Function | SmallTest | Level1)
1435 {
1436     time_t now;
1437     (void)time(&now);  // unit is seconds.
1438     struct tm nowTime;
1439     (void)localtime_r(&now, &nowTime);
1440 
1441     std::vector<uint8_t> repeatMonths;
1442     std::vector<uint8_t> repeatDays;
1443     std::vector<uint8_t> daysOfWeek;
1444     auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek);
1445     EXPECT_NE(nullptr, calendar);
1446 
1447     calendar->AddExcludeDate(static_cast<uint64_t>(now) * 1000);
1448     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1449 
1450     calendar->DeserializationExcludeDates("");
1451     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1452 
1453     calendar->DeserializationExcludeDates("saeawefs");
1454     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1455 
1456     calendar->DeserializationExcludeDates(R"({"pkgName":"com.example.myapplication"})");
1457     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1458 
1459     calendar->DeserializationExcludeDates(R"({"excludeDates":"com.example.myapplication"})");
1460     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1461 
1462     calendar->DeserializationExcludeDates(R"({"excludeDates":[]})");
1463     EXPECT_EQ(calendar->excludeDates_.size(), 0);
1464 
1465     calendar->DeserializationExcludeDates(R"({"excludeDates":["a"]})");
1466     EXPECT_EQ(calendar->excludeDates_.size(), 0);
1467 
1468     calendar->DeserializationExcludeDates(R"({"excludeDates":["a", 1713110400000]})");
1469     EXPECT_EQ(calendar->excludeDates_.size(), 1);
1470     EXPECT_NE(calendar->excludeDates_.find(1713110400000), calendar->excludeDates_.end());
1471 
1472     calendar->DeserializationExcludeDates(R"({"excludeDates":[1713196800000, 1713110400000]})");
1473     EXPECT_EQ(calendar->excludeDates_.size(), 2);
1474     EXPECT_NE(calendar->excludeDates_.find(1713196800000), calendar->excludeDates_.end());
1475 }
1476 
1477 /**
1478  * @tc.name: AppendValuesBucket_00001
1479  * @tc.desc: Test AppendValuesBucket parameters.
1480  * @tc.type: FUNC
1481  * @tc.require: issue#I9F24R
1482  */
1483 HWTEST_F(ReminderRequestCalendarTest, AppendValuesBucket_00001, Function | SmallTest | Level1)
1484 {
1485     time_t now;
1486     (void)time(&now);  // unit is seconds.
1487     struct tm nowTime;
1488     (void)localtime_r(&now, &nowTime);
1489 
1490     std::vector<uint8_t> repeatMonths;
1491     std::vector<uint8_t> repeatDays;
1492     std::vector<uint8_t> daysOfWeek;
1493     sptr<ReminderRequest> calendar = new ReminderRequestCalendar(nowTime, repeatMonths, repeatDays, daysOfWeek);
1494     EXPECT_NE(nullptr, calendar);
1495 }
1496 
1497 /**
1498  * @tc.name: IsPullUpService_00001
1499  * @tc.desc: Test IsPullUpService parameters.
1500  * @tc.type: FUNC
1501  * @tc.require:I9BM6I
1502  */
1503 HWTEST_F(ReminderRequestCalendarTest, IsPullUpService_00001, Function | SmallTest | Level1)
1504 {
1505     auto rrc = std::make_shared<ReminderRequestCalendar>();
1506     rrc->startDateTime_ = 1675876470000;
1507     EXPECT_EQ(rrc->IsPullUpService(), false);
1508 
1509     rrc->rruleWantAgentInfo_ = std::make_shared<ReminderRequest::WantAgentInfo>();
1510     EXPECT_EQ(rrc->IsPullUpService(), true);
1511 
1512     rrc->startDateTime_ = 1874643293000;
1513     EXPECT_EQ(rrc->IsPullUpService(), false);
1514 }
1515 
1516 /**
1517  * @tc.name: IsNeedNotification_00001
1518  * @tc.desc: Test IsNeedNotification parameters.
1519  * @tc.type: FUNC
1520  * @tc.require:I9BM6I
1521  */
1522 HWTEST_F(ReminderRequestCalendarTest, IsNeedNotification_00001, Function | SmallTest | Level1)
1523 {
1524     auto rrc = std::make_shared<ReminderRequestCalendar>();
1525     uint64_t now = rrc->GetNowInstantMilli();
1526     rrc->startDateTime_ = now - 5 * 60 * 1000;
1527     rrc->endDateTime_ = now + 5 * 60 * 1000;
1528     EXPECT_EQ(rrc->IsNeedNotification(), true);
1529 
1530     rrc->startDateTime_ = now + 10 * 60 * 1000;
1531     rrc->endDateTime_ = now + 20 * 60 * 1000;
1532     EXPECT_EQ(rrc->IsNeedNotification(), false);
1533 }
1534 }
1535 }