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_alarm.h"
21 #undef private
22 #undef protected
23 
24 #include "ans_log_wrapper.h"
25 #include "reminder_helper.h"
26 
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace Notification {
30 class ReminderRequestAlarmTest : public testing::Test {
31 public:
SetUpTestCase()32     static void SetUpTestCase() {}
TearDownTestCase()33     static void TearDownTestCase() {}
SetUp()34     void SetUp() {}
TearDown()35     void TearDown()
36     {
37         ReminderHelper::CancelAllReminders();
38     }
39 };
40 
41 /**
42  * @tc.name: initHour_00100
43  * @tc.desc: test set edge value of hour (0 and 23).
44  * @tc.type: FUNC
45  * @tc.require: SR000GGTRC AR000GH8E8
46  */
47 HWTEST_F(ReminderRequestAlarmTest, initHour_00100, Function | SmallTest | Level1)
48 {
49     std::vector<uint8_t> daysOfWeek;
50     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
51     EXPECT_TRUE(rrc->GetHour() == 0) << "hour should be 0";
52 
53     auto rrcB = std::make_shared<ReminderRequestAlarm>(23, 1, daysOfWeek);
54     EXPECT_TRUE(rrcB->GetHour() == 23) << "hour should be 23";
55 
56     auto rrcC = std::make_shared<ReminderRequestAlarm>(1, 1, daysOfWeek);
57     EXPECT_TRUE(rrcC->GetHour() == 1) << "hour should be 1";
58 
59     auto rrcD = std::make_shared<ReminderRequestAlarm>(22, 1, daysOfWeek);
60     EXPECT_TRUE(rrcD->GetHour() == 22) << "hour should be 22";
61 
62     auto rrcE = std::make_shared<ReminderRequestAlarm>(12, 1, daysOfWeek);
63     EXPECT_TRUE(rrcE->GetHour() == 12) << "hour should be 12";
64 }
65 
66 /**
67  * @tc.name: initHour_00200
68  * @tc.desc: test set edge value of minute (0 and 59).
69  * @tc.type: FUNC
70  * @tc.require: SR000GGTRC AR000GH8E8
71  */
72 HWTEST_F(ReminderRequestAlarmTest, initHour_00200, Function | SmallTest | Level1)
73 {
74     std::vector<uint8_t> daysOfWeek;
75     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
76     EXPECT_TRUE(rrc->GetMinute() == 0) << "minute should be 0";
77 
78     auto rrcB = std::make_shared<ReminderRequestAlarm>(23, 59, daysOfWeek);
79     EXPECT_TRUE(rrcB->GetMinute() == 59) << "minute should be 59";
80 }
81 
82 /**
83  * @tc.name: initDaysOfWeek_00100
84  * @tc.desc: test set daysOfWeek with normal value.
85  * @tc.type: FUNC
86  * @tc.require: SR000GGTRC AR000GH8E8
87  */
88 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00100, Function | SmallTest | Level1)
89 {
90     uint8_t arr[] = {1, 2, 3};
91     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
92     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
93     uint8_t expectedVal = 7;
94     EXPECT_TRUE(rrc->GetRepeatDaysOfWeek() == expectedVal) << "repeatDays (1, 2, 3) should be 7";
95 }
96 
97 /**
98  * @tc.name: initDaysOfWeek_00200
99  * @tc.desc: test set daysOfWeek with edge value.
100  * @tc.type: FUNC
101  * @tc.require: SR000GGTRC AR000GH8E8
102  */
103 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00200, Function | SmallTest | Level1)
104 {
105     uint8_t arr[] = {1, 7};
106     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
107     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
108     EXPECT_TRUE(rrc->GetRepeatDaysOfWeek() == 65) << "repeatDays (1, 12) should be 65";
109 }
110 
111 /**
112  * @tc.name: initDaysOfWeek_00300
113  * @tc.desc: test set daysOfWeek with duplicate value.
114  * @tc.type: FUNC
115  * @tc.require: SR000GGTRC AR000GH8E8
116  */
117 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00300, Function | SmallTest | Level1)
118 {
119     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
120     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
121     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
122     EXPECT_TRUE(rrc->GetRepeatDaysOfWeek() == 81) << "repeatDays (1, 1, 5 12) should be 81";
123 }
124 
125 /**
126  * @tc.name: initDaysOfWeek_00400
127  * @tc.desc: test set daysOfWeek with null value.
128  * @tc.type: FUNC
129  * @tc.require: SR000GGTRC AR000GH8E8
130  */
131 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00400, Function | SmallTest | Level1)
132 {
133     uint8_t arr[] = {};
134     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
135     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
136     uint8_t expectedVal = 0;
137     EXPECT_TRUE(rrc->GetRepeatDaysOfWeek() == expectedVal) << "repeatDays () should be 0";
138 }
139 
140 /**
141  * @tc.name: IsRepeatReminder_00100
142  * @tc.desc: Test IsRepeatReminder parameters.
143  * @tc.type: FUNC
144  * @tc.require: issue
145  */
146 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00100, Function | SmallTest | Level1)
147 {
148     uint8_t arr[] = {};
149     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
150     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
151     EXPECT_EQ(rrc->IsRepeatReminder(), false);
152     EXPECT_EQ(rrc->UpdateNextReminder(), false);
153 }
154 
155 /**
156  * @tc.name: IsRepeatReminder_00200
157  * @tc.desc: Test IsRepeatReminder parameters.
158  * @tc.type: FUNC
159  * @tc.require: issue
160  */
161 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00200, Function | SmallTest | Level1)
162 {
163     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
164     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
165     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
166     EXPECT_EQ(rrc->IsRepeatReminder(), true);
167     EXPECT_EQ(rrc->UpdateNextReminder(), true);
168 }
169 
170 /**
171  * @tc.name: IsRepeatReminder_00300
172  * @tc.desc: Test IsRepeatReminder parameters.
173  * @tc.type: FUNC
174  * @tc.require: issue
175  */
176 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00300, Function | SmallTest | Level1)
177 {
178     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
179     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
180     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
181 
182     auto ret = std::make_shared<ReminderRequest>();
183     ret->SetSnoozeTimes(1);
184     EXPECT_EQ(ret->GetSnoozeTimes(), 1);
185 
186     uint32_t minTimeIntervalInSecond = 300;
187     ret->SetTimeInterval(1);
188     EXPECT_EQ(ret->GetTimeInterval(), minTimeIntervalInSecond);
189     EXPECT_EQ(rrc->IsRepeatReminder(), true);
190 }
191 
192 /**
193  * @tc.name: IsRepeatReminder_00400
194  * @tc.desc: Test IsRepeatReminder parameters.
195  * @tc.type: FUNC
196  * @tc.require: issue
197  */
198 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00400, Function | SmallTest | Level1)
199 {
200     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
201     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
202     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
203 
204     auto ret = std::make_shared<ReminderRequest>();
205     ret->SetSnoozeTimes(0);
206     EXPECT_EQ(ret->GetSnoozeTimes(), 0);
207 
208     uint32_t minTimeIntervalInSecond = 300;
209     ret->SetTimeInterval(1);
210     EXPECT_EQ(ret->GetTimeInterval(), minTimeIntervalInSecond);
211     EXPECT_EQ(rrc->IsRepeatReminder(), true);
212 }
213 
214 /**
215  * @tc.name: IsRepeatReminder_00500
216  * @tc.desc: Test IsRepeatReminder parameters.
217  * @tc.type: FUNC
218  * @tc.require: issue
219  */
220 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00500, Function | SmallTest | Level1)
221 {
222     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
223     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
224     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
225 
226     auto ret = std::make_shared<ReminderRequest>();
227     ret->SetSnoozeTimes(1);
228     EXPECT_EQ(ret->GetSnoozeTimes(), 1);
229 
230     uint32_t minTimeIntervalInSecond = 0;
231     ret->SetTimeInterval(0);
232     EXPECT_EQ(ret->GetTimeInterval(), minTimeIntervalInSecond);
233     EXPECT_EQ(rrc->IsRepeatReminder(), true);
234 }
235 
236 /**
237  * @tc.name: IsRepeatReminder_00600
238  * @tc.desc: Test IsRepeatReminder parameters.
239  * @tc.type: FUNC
240  * @tc.require: issue
241  */
242 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00600, Function | SmallTest | Level1)
243 {
244     uint8_t arr[] = {};
245     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
246     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
247 
248     auto ret = std::make_shared<ReminderRequest>();
249     ret->SetSnoozeTimes(1);
250     EXPECT_EQ(ret->GetSnoozeTimes(), 1);
251 
252     uint32_t minTimeIntervalInSecond = 300;
253     rrc->SetTimeInterval(1);
254     EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond);
255     EXPECT_EQ(rrc->IsRepeatReminder(), true);
256 }
257 
258 /**
259  * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_00100
260  * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters.
261  * @tc.type: FUNC
262  * @tc.require: issue
263  */
264 HWTEST_F(ReminderRequestAlarmTest, PreGetNextTriggerTimeIgnoreSnooze_00100, Function | SmallTest | Level1)
265 {
266     bool ignoreRepeat = true;
267     bool forceToGetNext = true;
268     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
269     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
270     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
271     rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext);
272     EXPECT_EQ(rrc->GetNextTriggerTime(forceToGetNext),
273     rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext));
274 }
275 
276 /**
277  * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_00200
278  * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters.
279  * @tc.type: FUNC
280  * @tc.require: issue
281  */
282 HWTEST_F(ReminderRequestAlarmTest, PreGetNextTriggerTimeIgnoreSnooze_00200, Function | SmallTest | Level1)
283 {
284     uint8_t arr[] = {};
285     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
286     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
287 
288     bool ignoreRepeat = false;
289     bool forceToGetNext = false;
290     uint64_t result = rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext);
291     EXPECT_EQ(result, ReminderRequest::INVALID_LONG_LONG_VALUE);
292 }
293 
294 /**
295  * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_00300
296  * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters.
297  * @tc.type: FUNC
298  * @tc.require: issue
299  */
300 HWTEST_F(ReminderRequestAlarmTest, PreGetNextTriggerTimeIgnoreSnooze_00300, Function | SmallTest | Level1)
301 {
302     bool ignoreRepeat = true;
303     bool forceToGetNext = true;
304     uint8_t arr[] = {};
305     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
306     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
307 
308     rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext);
309     EXPECT_EQ(rrc->GetNextTriggerTime(forceToGetNext),
310     rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext));
311 }
312 
313 /**
314  * @tc.name: GetDaysOfWeek_00100
315  * @tc.desc: Test GetDaysOfWeek parameters.
316  * @tc.type: FUNC
317  * @tc.require: issue
318  */
319 HWTEST_F(ReminderRequestAlarmTest, GetDaysOfWeek_00100, Function | SmallTest | Level1)
320 {
321     uint8_t arr[] = {};
322     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
323     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
324     auto ret = rrc->GetDaysOfWeek();
325     EXPECT_EQ(ret.size(), 0);
326 }
327 
328 /**
329  * @tc.name: OnDateTimeChange_00100
330  * @tc.desc: Test OnDateTimeChange parameters.
331  * @tc.type: FUNC
332  * @tc.require: issue
333  */
334 HWTEST_F(ReminderRequestAlarmTest, OnDateTimeChange_00100, Function | SmallTest | Level1)
335 {
336     uint8_t arr[] = {};
337     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
338     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
339     EXPECT_EQ(rrc->OnDateTimeChange(), false);
340 }
341 
342 /**
343  * @tc.name: RecoverFromDb_00100
344  * @tc.desc: Test RecoverFromDb parameters.
345  * @tc.type: FUNC
346  * @tc.require: issue
347  */
348 HWTEST_F(ReminderRequestAlarmTest, RecoverFromDb_00100, Function | SmallTest | Level1)
349 {
350     uint8_t arr[] = {};
351     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
352     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
353     uint8_t ret = rrc->GetRepeatDaysOfWeek();
354     EXPECT_EQ(ret, 0);
355 }
356 
357 /**
358  * @tc.name: Marshalling_00001
359  * @tc.desc: Test Marshalling parameters.
360  * @tc.type: FUNC
361  * @tc.require: issue
362  */
363 HWTEST_F(ReminderRequestAlarmTest, Marshalling_00001, Function | SmallTest | Level1)
364 {
365     Parcel parcel;
366     uint8_t arr[] = {};
367     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
368     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
369     EXPECT_EQ(rrc->Marshalling(parcel), true);
370 }
371 
372 /**
373  * @tc.name: Unmarshalling_00001
374  * @tc.desc: Test Unmarshalling parameters.
375  * @tc.type: FUNC
376  * @tc.require: issue
377  */
378 HWTEST_F(ReminderRequestAlarmTest, Unmarshalling_001, Function | SmallTest | Level1)
379 {
380     bool unmarshalling = true;
381     Parcel parcel;
382     uint8_t arr[] = {};
383     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
384     std::shared_ptr<ReminderRequestAlarm> result =
385     std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
386     if (nullptr != result) {
387         if (nullptr == result->Unmarshalling(parcel)) {
388             unmarshalling = false;
389         }
390     }
391     EXPECT_EQ(unmarshalling, false);
392 }
393 
394 /**
395  * @tc.name: ReadFromParcel_00001
396  * @tc.desc: Test ReadFromParcel parameters.
397  * @tc.type: FUNC
398  * @tc.require: issueI
399  */
400 HWTEST_F(ReminderRequestAlarmTest, ReadFromParcel_00001, Function | SmallTest | Level1)
401 {
402     Parcel parcel;
403     uint8_t arr[] = {};
404     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
405     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
406     EXPECT_EQ(rrc->ReadFromParcel(parcel), false);
407 }
408 
409 /**
410  * @tc.name: CheckParamValid_00100
411  * @tc.desc: Test CheckParamValid parameters.
412  * @tc.type: FUNC
413  * @tc.require: issue
414  */
415 HWTEST_F(ReminderRequestAlarmTest, CheckParamValid_00100, Function | SmallTest | Level1)
416 {
417     uint8_t arr[] = {};
418     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
419     auto rrc = std::make_shared<ReminderRequestAlarm>(25, 0, daysOfWeek);
420 
421     rrc->CheckParamValid();
422     uint8_t ret = 25;
423     EXPECT_EQ(rrc->GetHour(), ret);
424 }
425 
426 /**
427  * @tc.name: CheckParamValid_00200
428  * @tc.desc: Test CheckParamValid parameters.
429  * @tc.type: FUNC
430  * @tc.require: issue
431  */
432 HWTEST_F(ReminderRequestAlarmTest, CheckParamValid_00200, Function | SmallTest | Level1)
433 {
434     uint8_t arr[] = {};
435     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
436     auto rrc = std::make_shared<ReminderRequestAlarm>(2, 61, daysOfWeek);
437 
438     rrc->CheckParamValid();
439     uint8_t ret = 61;
440     EXPECT_EQ(rrc->GetMinute(), ret);
441 }
442 
443 /**
444  * @tc.name: SetDaysOfWeek_00100
445  * @tc.desc: Test SetRepeatDaysOfWeek parameters.
446  * @tc.type: FUNC
447  * @tc.require: issue
448  */
449 HWTEST_F(ReminderRequestAlarmTest, SetDaysOfWeek_00100, Function | SmallTest | Level1)
450 {
451     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7, 8};
452     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
453     auto rrc = std::make_shared<ReminderRequestAlarm>(1, 1, daysOfWeek);
454 
455     bool set = true;
456     rrc->SetRepeatDaysOfWeek(set, daysOfWeek);
457     std::vector<int32_t> result = rrc->GetDaysOfWeek();
458     EXPECT_EQ(result.size(), 0);
459 }
460 
461 /**
462  * @tc.name: SetDaysOfWeek_00200
463  * @tc.desc: Test SetRepeatDaysOfWeek parameters.
464  * @tc.type: FUNC
465  * @tc.require: issue
466  */
467 HWTEST_F(ReminderRequestAlarmTest, SetDaysOfWeek_00200, Function | SmallTest | Level1)
468 {
469     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
470     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
471     auto rrc = std::make_shared<ReminderRequestAlarm>(1, 1, daysOfWeek);
472 
473     bool set = false;
474     rrc->SetRepeatDaysOfWeek(set, daysOfWeek);
475     std::vector<int32_t> result = rrc->GetDaysOfWeek();
476     EXPECT_EQ(result.size(), 0);
477 }
478 
479 /**
480  * @tc.name: UpdateNextReminder_00100
481  * @tc.desc: Test UpdateNextReminder parameters.
482  * @tc.type: FUNC
483  * @tc.require: issue
484  */
485 HWTEST_F(ReminderRequestAlarmTest, UpdateNextReminder_00100, Function | SmallTest | Level1)
486 {
487     uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7};
488     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
489     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek);
490     EXPECT_EQ(rrc->IsRepeatReminder(), true);
491 
492     auto ret = std::make_shared<ReminderRequest>();
493     ret->SetSnoozeTimesDynamic(1);
494     EXPECT_EQ(ret->GetSnoozeTimesDynamic(), 1);
495     uint32_t minTimeIntervalInSecond = 300;
496     ret->SetTimeInterval(1);
497     EXPECT_EQ(ret->GetTimeInterval(), minTimeIntervalInSecond);
498     EXPECT_EQ(rrc->UpdateNextReminder(), true);
499 }
500 
501 /**
502  * @tc.name: UpdateNextReminder_00200
503  * @tc.desc: Test UpdateNextReminder parameters.
504  * @tc.type: FUNC
505  * @tc.require: issue
506  */
507 HWTEST_F(ReminderRequestAlarmTest, UpdateNextReminder_00200, Function | SmallTest | Level1)
508 {
509     uint8_t arr[] = {};
510     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
511     auto reminderRequestAlarm = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
512 
513     auto ret = std::make_shared<ReminderRequest>();
514     ret->SetSnoozeTimes(1);
515     EXPECT_EQ(ret->GetSnoozeTimes(), 1);
516 
517     uint32_t minTimeIntervalInSecond = 300;
518     reminderRequestAlarm->SetTimeInterval(1);
519     EXPECT_EQ(reminderRequestAlarm->GetTimeInterval(), minTimeIntervalInSecond);
520 
521     ret->SetSnoozeTimesDynamic(0);
522     EXPECT_EQ(ret->GetSnoozeTimesDynamic(), 0);
523     uint8_t result = reminderRequestAlarm->GetRepeatDaysOfWeek();
524     EXPECT_EQ(result, 0);
525     EXPECT_EQ(reminderRequestAlarm->IsRepeatReminder(), true);
526     EXPECT_EQ(reminderRequestAlarm->UpdateNextReminder(), true);
527 }
528 
529 /**
530  * @tc.name: RecoverFromOldVersion_00001
531  * @tc.desc: Test RecoverFromDb parameters.
532  * @tc.type: FUNC
533  * @tc.require: issueI92BU9
534  */
535 HWTEST_F(ReminderRequestAlarmTest, RecoverFromOldVersion_00001, Function | SmallTest | Level1)
536 {
537     uint8_t arr[] = {};
538     std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t));
539     auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek);
540     uint8_t ret = rrc->GetRepeatDaysOfWeek();
541     EXPECT_EQ(ret, 0);
542 }
543 }
544 }