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