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