1 /* 2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 18 #define private public 19 #define protected public 20 #include "reminder_request_calendar.h" 21 #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 ReminderRequestCalendarTest : public testing::Test { 31 public: SetUpTestCase()32 static void SetUpTestCase() 33 { 34 ReminderHelper::CancelAllReminders(); 35 } SetUp()36 void SetUp() {} TearDownTestCase()37 static void TearDownTestCase() {} TearDown()38 void TearDown() 39 { 40 ReminderHelper::CancelAllReminders(); 41 } 42 CreateCalendar(tm & nowTime)43 std::shared_ptr<ReminderRequestCalendar> CreateCalendar(tm &nowTime) 44 { 45 time_t now; 46 (void)time(&now); // unit is seconds. 47 tm *tmp = localtime(&now); 48 if (tmp == nullptr) { 49 return nullptr; 50 } 51 nowTime = *tmp; 52 nowTime.tm_year = 0; 53 nowTime.tm_mon = 0; 54 nowTime.tm_mday = 1; 55 nowTime.tm_hour = 1; 56 nowTime.tm_min = 1; 57 std::vector<uint8_t> repeatMonths; 58 std::vector<uint8_t> repeatDays; 59 std::vector<uint8_t> daysOfWeek; 60 repeatMonths.push_back(1); 61 repeatDays.push_back(1); 62 daysOfWeek.push_back(1); 63 auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 64 calendar->SetNextTriggerTime(); 65 return calendar; 66 } 67 IsVectorEqual(std::vector<uint8_t> & vectorA,std::vector<uint8_t> & vectorB)68 bool IsVectorEqual(std::vector<uint8_t> &vectorA, std::vector<uint8_t> &vectorB) 69 { 70 if (vectorA.size() != vectorB.size()) { 71 return false; 72 } 73 if (vectorA.size() == 0) { 74 return true; 75 } 76 auto vitA = vectorA.begin(); 77 auto vitB = vectorB.begin(); 78 while (vitA != vectorA.end()) { 79 if (*vitA != *vitB) { 80 return false; 81 } 82 ++vitA; 83 ++vitB; 84 } 85 return true; 86 } 87 }; 88 89 /** 90 * @tc.name: initDateTime_00100 91 * @tc.desc: Check firstDesignateYear set successfully. 92 * @tc.type: FUNC 93 * @tc.require: SR000GN4CU AR000GNF1V 94 */ 95 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00100, Function | SmallTest | Level1) 96 { 97 struct tm nowTime; 98 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 99 EXPECT_NE(nullptr, calendar); 100 int32_t firstDesignateYear = calendar->GetActualTime(ReminderRequest::TimeTransferType::YEAR, nowTime.tm_year); 101 EXPECT_TRUE(firstDesignateYear == calendar->GetFirstDesignateYear()) << "Set first designate year error."; 102 } 103 104 /** 105 * @tc.name: initDateTime_00200 106 * @tc.desc: Check firstDesignateMonth set successfully. 107 * @tc.type: FUNC 108 * @tc.require: SR000GN4CU AR000GNF1V 109 */ 110 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00200, Function | SmallTest | Level1) 111 { 112 struct tm nowTime; 113 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 114 EXPECT_NE(nullptr, calendar); 115 int firstDesignateMonth = calendar->GetActualTime(ReminderRequest::TimeTransferType::MONTH, nowTime.tm_mon); 116 EXPECT_TRUE(firstDesignateMonth == calendar->GetFirstDesignageMonth()) << "Set first designate month error."; 117 } 118 119 /** 120 * @tc.name: initDateTime_00300 121 * @tc.desc: Check firstDesignateDay set successfully. 122 * @tc.type: FUNC 123 * @tc.require: SR000GN4CU AR000GNF1V 124 */ 125 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00300, Function | SmallTest | Level1) 126 { 127 struct tm nowTime; 128 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 129 EXPECT_NE(nullptr, calendar); 130 int firstDesignateDay = nowTime.tm_mday; 131 EXPECT_TRUE(firstDesignateDay == calendar->GetFirstDesignateDay()) << "Set first designate day error."; 132 } 133 134 /** 135 * @tc.name: initDateTime_00400 136 * @tc.desc: Check repeatMonth set with normal value successfully. 137 * @tc.type: FUNC 138 * @tc.require: SR000GN4CU AR000GNF1V 139 */ 140 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00400, Function | SmallTest | Level1) 141 { 142 time_t now; 143 (void)time(&now); // unit is seconds. 144 tm *tmp = localtime(&now); 145 EXPECT_NE(nullptr, tmp); 146 struct tm nowTime = *tmp; 147 148 std::vector<uint8_t> repeatMonths; 149 std::vector<uint8_t> repeatDays; 150 std::vector<uint8_t> daysOfWeek; 151 daysOfWeek.push_back(1); 152 repeatMonths.push_back(1); 153 repeatDays.push_back(1); 154 auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 155 calendar->SetNextTriggerTime(); 156 std::vector<uint8_t> actualRepeatMonths = calendar->GetRepeatMonths(); 157 EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatMonths, actualRepeatMonths)) 158 << "Set repeat month with 1 error."; 159 160 repeatMonths.clear(); 161 repeatMonths.push_back(12); 162 calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 163 calendar->SetNextTriggerTime(); 164 actualRepeatMonths = calendar->GetRepeatMonths(); 165 EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatMonths, actualRepeatMonths)) 166 << "Set repeat month with 12 error."; 167 168 repeatMonths.clear(); 169 for (uint8_t i = 1; i <= 12; i++) { 170 repeatMonths.push_back(i); 171 } 172 calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 173 calendar->SetNextTriggerTime(); 174 actualRepeatMonths = calendar->GetRepeatMonths(); 175 EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatMonths, actualRepeatMonths)) 176 << "Set repeat month with 1~12 error."; 177 } 178 179 /** 180 * @tc.name: initDateTime_00500 181 * @tc.desc: Check repeatMonth set with exception value successfully. 182 * @tc.type: FUNC 183 * @tc.require: SR000GN4CU AR000GNF1V 184 */ 185 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00500, Function | SmallTest | Level1) 186 { 187 time_t now; 188 time(&now); // unit is seconds. 189 tm *tmp = localtime(&now); 190 EXPECT_NE(nullptr, tmp); 191 tm nowTime = *tmp; 192 nowTime.tm_year += 1; 193 std::vector<uint8_t> repeatMonth; 194 std::vector<uint8_t> repeatDay; 195 std::vector<uint8_t> daysOfWeek; 196 daysOfWeek.push_back(1); 197 repeatMonth.push_back(-1); 198 repeatDay.push_back(1); 199 auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonth, repeatDay, daysOfWeek); 200 calendar->SetNextTriggerTime(); 201 std::vector<uint8_t> actualRepeatMonths = calendar->GetRepeatMonths(); 202 EXPECT_TRUE(actualRepeatMonths.size() == 0) << "Set repeat month with -1 error."; 203 204 repeatMonth.clear(); 205 repeatMonth.push_back(13); 206 calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonth, repeatDay, daysOfWeek); 207 calendar->SetNextTriggerTime(); 208 actualRepeatMonths = calendar->GetRepeatMonths(); 209 EXPECT_TRUE(actualRepeatMonths.size() == 0) << "Set repeat month with 13 error."; 210 } 211 212 /** 213 * @tc.name: initDateTime_00600 214 * @tc.desc: Check repeatDay set with nomal value successfully. 215 * @tc.type: FUNC 216 * @tc.require: SR000GN4CU AR000GNF1V 217 */ 218 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00600, Function | SmallTest | Level1) 219 { 220 time_t now; 221 (void)time(&now); // unit is seconds. 222 tm *tmp = localtime(&now); 223 EXPECT_NE(nullptr, tmp); 224 tm nowTime = *tmp; 225 std::vector<uint8_t> repeatMonths; 226 std::vector<uint8_t> repeatDays; 227 std::vector<uint8_t> daysOfWeek; 228 daysOfWeek.push_back(1); 229 repeatMonths.push_back(1); 230 repeatDays.push_back(1); 231 auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 232 calendar->SetNextTriggerTime(); 233 std::vector<uint8_t> actualRepeatDays = calendar->GetRepeatDays(); 234 EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatDays, actualRepeatDays)) 235 << "Set repeat day with 1 error."; 236 237 repeatDays.clear(); 238 repeatDays.push_back(31); 239 calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 240 calendar->SetNextTriggerTime(); 241 actualRepeatDays = calendar->GetRepeatDays(); 242 EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatDays, actualRepeatDays)) 243 << "Set repeat day with 31 error."; 244 245 repeatDays.clear(); 246 for (uint8_t i = 1; i <= 31; i++) { 247 repeatDays.push_back(i); 248 } 249 calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 250 calendar->SetNextTriggerTime(); 251 actualRepeatDays = calendar->GetRepeatDays(); 252 EXPECT_TRUE(ReminderRequestCalendarTest::IsVectorEqual(repeatDays, actualRepeatDays)) 253 << "Set repeat day with 1~31 error."; 254 } 255 256 /** 257 * @tc.name: initDateTime_00700 258 * @tc.desc: Check repeatDay set with exception value successfully. 259 * @tc.type: FUNC 260 * @tc.require: SR000GN4CU AR000GNF1V 261 */ 262 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00700, Function | SmallTest | Level1) 263 { 264 time_t now; 265 (void)time(&now); // unit is seconds. 266 tm *tmp = localtime(&now); 267 EXPECT_NE(nullptr, tmp); 268 tm nowTime = *tmp; 269 nowTime.tm_year += 1; 270 std::vector<uint8_t> repeatMonths; 271 std::vector<uint8_t> repeatDays; 272 std::vector<uint8_t> daysOfWeek; 273 daysOfWeek.push_back(-1); 274 repeatMonths.push_back(-1); 275 repeatDays.push_back(-1); 276 auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 277 calendar->SetNextTriggerTime(); 278 std::vector<uint8_t> actualRepeatDays = calendar->GetRepeatDays(); 279 EXPECT_TRUE(actualRepeatDays.size() == 0) << "Set repeat day with -1 error."; 280 281 repeatDays.clear(); 282 repeatDays.push_back(32); 283 calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 284 calendar->SetNextTriggerTime(); 285 actualRepeatDays = calendar->GetRepeatDays(); 286 EXPECT_TRUE(actualRepeatDays.size() == 0) << "Set repeat day with 32 error."; 287 } 288 289 /** 290 * @tc.name: initDateTime_00800 291 * @tc.desc: Check hour set successfully. 292 * @tc.type: FUNC 293 * @tc.require: SR000GN4CU AR000GNF1V 294 */ 295 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00800, Function | SmallTest | Level1) 296 { 297 struct tm nowTime; 298 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 299 EXPECT_NE(nullptr, calendar); 300 EXPECT_TRUE(1 == calendar->GetHour()) << "Set hour error."; 301 } 302 303 /** 304 * @tc.name: initDateTime_00900 305 * @tc.desc: Check minut set successfully. 306 * @tc.type: FUNC 307 * @tc.require: SR000GN4CU AR000GNF1V 308 */ 309 HWTEST_F(ReminderRequestCalendarTest, initDateTime_00900, Function | SmallTest | Level1) 310 { 311 struct tm nowTime; 312 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 313 EXPECT_NE(nullptr, calendar); 314 EXPECT_TRUE(1 == calendar->GetMinute()) << "Set minute error."; 315 EXPECT_TRUE(0 == calendar->GetSecond()) << "Set seconds error."; 316 } 317 318 /** 319 * @tc.name: initDateTime_01000 320 * @tc.desc: Test InitDateTime parameters. 321 * @tc.type: FUNC 322 * @tc.require: issue 323 */ 324 HWTEST_F(ReminderRequestCalendarTest, initDateTime_01000, Function | SmallTest | Level1) 325 { 326 struct tm nowTime; 327 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 328 EXPECT_NE(nullptr, calendar); 329 calendar->InitDateTime(); 330 EXPECT_EQ(calendar->IsRepeatReminder(), true); 331 } 332 333 /** 334 * @tc.name: OnDateTimeChange_01000 335 * @tc.desc: Test OnDateTimeChange parameters. 336 * @tc.type: FUNC 337 * @tc.require: issue 338 */ 339 HWTEST_F(ReminderRequestCalendarTest, OnDateTimeChange_01000, Function | SmallTest | Level1) 340 { 341 struct tm nowTime; 342 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 343 EXPECT_NE(nullptr, calendar); 344 EXPECT_EQ(calendar->OnDateTimeChange(), false); 345 } 346 347 /** 348 * @tc.name: OnTimeZoneChange_01000 349 * @tc.desc: Test OnTimeZoneChange parameters. 350 * @tc.type: FUNC 351 * @tc.require: issue 352 */ 353 HWTEST_F(ReminderRequestCalendarTest, OnTimeZoneChange_01000, Function | SmallTest | Level1) 354 { 355 struct tm nowTime; 356 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 357 EXPECT_NE(nullptr, calendar); 358 EXPECT_EQ(calendar->OnTimeZoneChange(), false); 359 } 360 361 /** 362 * @tc.name: UpdateNextReminder_01000 363 * @tc.desc: Test UpdateNextReminder parameters. 364 * @tc.type: FUNC 365 * @tc.require: issue 366 */ 367 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_01000, Function | SmallTest | Level1) 368 { 369 struct tm nowTime; 370 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 371 EXPECT_NE(nullptr, calendar); 372 EXPECT_EQ(calendar->UpdateNextReminder(), true); 373 } 374 375 /** 376 * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_01000 377 * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters. 378 * @tc.type: FUNC 379 * @tc.require: issue 380 */ 381 HWTEST_F(ReminderRequestCalendarTest, PreGetNextTriggerTimeIgnoreSnooze_01000, Function | SmallTest | Level1) 382 { 383 bool ignoreRepeat = true; 384 bool forceToGetNext = true; 385 struct tm nowTime; 386 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 387 EXPECT_NE(nullptr, calendar); 388 EXPECT_EQ(calendar->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext), 389 calendar->GetNextTriggerTime()); 390 } 391 392 /** 393 * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_03000 394 * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters. 395 * @tc.type: FUNC 396 * @tc.require: issue 397 */ 398 HWTEST_F(ReminderRequestCalendarTest, PreGetNextTriggerTimeIgnoreSnooze_03000, Function | SmallTest | Level1) 399 { 400 bool ignoreRepeat = false; 401 bool forceToGetNext = true; 402 struct tm nowTime; 403 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 404 EXPECT_NE(nullptr, calendar); 405 std::shared_ptr<NativeRdb::ResultSet> resultSet = 406 std::make_shared<NativeRdb::AbsSharedResultSet>(); 407 calendar->RecoverFromDb(resultSet); 408 409 EXPECT_EQ(calendar->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext), 410 calendar->GetNextTriggerTime()); 411 } 412 413 /** 414 * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_02000 415 * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters. 416 * @tc.type: FUNC 417 * @tc.require: issue 418 */ 419 HWTEST_F(ReminderRequestCalendarTest, PreGetNextTriggerTimeIgnoreSnooze_02000, Function | SmallTest | Level1) 420 { 421 bool ignoreRepeat = false; 422 bool forceToGetNext = true; 423 time_t now; 424 time(&now); // unit is seconds. 425 tm *tmp = localtime(&now); 426 EXPECT_NE(nullptr, tmp); 427 tm nowTime = *tmp; 428 nowTime.tm_year += 1; 429 std::vector<uint8_t> repeatMonths; 430 std::vector<uint8_t> repeatDays; 431 std::vector<uint8_t> daysOfWeek; 432 daysOfWeek.push_back(-1); 433 repeatMonths.push_back(-1); 434 repeatDays.push_back(-1); 435 auto calendar = std::make_shared<ReminderRequestCalendar>(nowTime, repeatMonths, repeatDays, daysOfWeek); 436 EXPECT_EQ(calendar->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext), 0); 437 } 438 439 /** 440 * @tc.name: Marshalling_00001 441 * @tc.desc: Test Marshalling parameters. 442 * @tc.type: FUNC 443 * @tc.require: issue 444 */ 445 HWTEST_F(ReminderRequestCalendarTest, Marshalling_00001, Function | SmallTest | Level1) 446 { 447 Parcel parcel; 448 struct tm nowTime; 449 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 450 EXPECT_NE(nullptr, calendar); 451 EXPECT_EQ(calendar->Marshalling(parcel), true); 452 } 453 454 /** 455 * @tc.name: Unmarshalling_00001 456 * @tc.desc: Test Unmarshalling parameters. 457 * @tc.type: FUNC 458 * @tc.require: issue 459 */ 460 HWTEST_F(ReminderRequestCalendarTest, Unmarshalling_001, Function | SmallTest | Level1) 461 { 462 bool unmarshalling = true; 463 Parcel parcel; 464 struct tm nowTime; 465 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 466 EXPECT_NE(nullptr, calendar); 467 if (nullptr != calendar) { 468 if (nullptr == calendar->Unmarshalling(parcel)) { 469 unmarshalling = false; 470 } 471 } 472 EXPECT_EQ(unmarshalling, false); 473 } 474 475 /** 476 * @tc.name: ReadFromParcel_00001 477 * @tc.desc: Test ReadFromParcel parameters. 478 * @tc.type: FUNC 479 * @tc.require: issueI 480 */ 481 HWTEST_F(ReminderRequestCalendarTest, ReadFromParcel_00001, Function | SmallTest | Level1) 482 { 483 Parcel parcel; 484 struct tm nowTime; 485 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 486 EXPECT_NE(nullptr, calendar); 487 EXPECT_EQ(calendar->ReadFromParcel(parcel), false); 488 } 489 490 /** 491 * @tc.name: GetDaysOfMonth_00001 492 * @tc.desc: Test GetDaysOfMonth parameters. 493 * @tc.type: FUNC 494 * @tc.require: issue 495 */ 496 HWTEST_F(ReminderRequestCalendarTest, GetDaysOfMonth_00001, Function | SmallTest | Level1) 497 { 498 struct tm nowTime; 499 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 500 EXPECT_NE(nullptr, calendar); 501 502 uint16_t year = 1; 503 uint8_t month = 2; 504 uint8_t result = calendar->GetDaysOfMonth(year, month); 505 uint8_t ret = 28; 506 EXPECT_EQ(result, ret); 507 } 508 509 /** 510 * @tc.name: SetDay_00001 511 * @tc.desc: Test SetDay parameters. 512 * @tc.type: FUNC 513 * @tc.require: issue 514 */ 515 HWTEST_F(ReminderRequestCalendarTest, SetDay_00001, Function | SmallTest | Level1) 516 { 517 struct tm nowTime; 518 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 519 EXPECT_NE(nullptr, calendar); 520 521 uint8_t day = -1; 522 bool isSet = false; 523 calendar->SetDay(day, isSet); 524 bool result = calendar->IsRepeatDay(day); 525 EXPECT_EQ(result, false); 526 } 527 528 /** 529 * @tc.name: SetDay_00002 530 * @tc.desc: Test SetDay parameters. 531 * @tc.type: FUNC 532 * @tc.require: issue 533 */ 534 HWTEST_F(ReminderRequestCalendarTest, SetDay_00002, Function | SmallTest | Level1) 535 { 536 struct tm nowTime; 537 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 538 EXPECT_NE(nullptr, calendar); 539 540 uint8_t day = 32; 541 bool isSet = false; 542 calendar->SetDay(day, isSet); 543 bool result = calendar->IsRepeatDay(day); 544 EXPECT_EQ(result, false); 545 } 546 547 /** 548 * @tc.name: SetMonth_00001 549 * @tc.desc: Test SetMonth parameters. 550 * @tc.type: FUNC 551 * @tc.require: issue 552 */ 553 HWTEST_F(ReminderRequestCalendarTest, SetMonth_00001, Function | SmallTest | Level1) 554 { 555 struct tm nowTime; 556 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 557 EXPECT_NE(nullptr, calendar); 558 559 uint8_t month = -1; 560 bool isSet = false; 561 calendar->SetMonth(month, isSet); 562 bool result = calendar->IsRepeatMonth(month); 563 EXPECT_EQ(result, false); 564 } 565 566 /** 567 * @tc.name: SetMonth_00002 568 * @tc.desc: Test SetMonth parameters. 569 * @tc.type: FUNC 570 * @tc.require: issue 571 */ 572 HWTEST_F(ReminderRequestCalendarTest, SetMonth_00002, Function | SmallTest | Level1) 573 { 574 struct tm nowTime; 575 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 576 EXPECT_NE(nullptr, calendar); 577 578 uint8_t month = 13; 579 bool isSet = false; 580 calendar->SetMonth(month, isSet); 581 bool result = calendar->IsRepeatMonth(month); 582 EXPECT_EQ(result, false); 583 } 584 585 /** 586 * @tc.name: SetRepeatDaysOfMonth_00001 587 * @tc.desc: Test SetRepeatDaysOfMonth parameters. 588 * @tc.type: FUNC 589 * @tc.require: issue 590 */ 591 HWTEST_F(ReminderRequestCalendarTest, SetRepeatDaysOfMonth_00001, Function | SmallTest | Level1) 592 { 593 struct tm nowTime; 594 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 595 EXPECT_NE(nullptr, calendar); 596 597 std::vector<uint8_t> repeatDays; 598 repeatDays.emplace_back(1); 599 repeatDays.emplace_back(2); 600 repeatDays.emplace_back(3); 601 repeatDays.emplace_back(4); 602 repeatDays.emplace_back(5); 603 repeatDays.emplace_back(6); 604 repeatDays.emplace_back(7); 605 repeatDays.emplace_back(8); 606 repeatDays.emplace_back(9); 607 repeatDays.emplace_back(10); 608 repeatDays.emplace_back(11); 609 repeatDays.emplace_back(12); 610 repeatDays.emplace_back(13); 611 repeatDays.emplace_back(14); 612 repeatDays.emplace_back(15); 613 repeatDays.emplace_back(16); 614 repeatDays.emplace_back(17); 615 repeatDays.emplace_back(18); 616 repeatDays.emplace_back(19); 617 repeatDays.emplace_back(20); 618 repeatDays.emplace_back(21); 619 repeatDays.emplace_back(22); 620 repeatDays.emplace_back(23); 621 repeatDays.emplace_back(24); 622 repeatDays.emplace_back(25); 623 repeatDays.emplace_back(26); 624 repeatDays.emplace_back(27); 625 repeatDays.emplace_back(28); 626 repeatDays.emplace_back(29); 627 repeatDays.emplace_back(30); 628 repeatDays.emplace_back(31); 629 repeatDays.emplace_back(32); 630 EXPECT_EQ(repeatDays.size(), 32); 631 632 calendar->SetRepeatDaysOfMonth(repeatDays); 633 std::vector<uint8_t> result = calendar->GetRepeatMonths(); 634 EXPECT_EQ(result.size(), 1); 635 } 636 637 /** 638 * @tc.name: UpdateNextReminder_00001 639 * @tc.desc: Test UpdateNextReminder parameters. 640 * @tc.type: FUNC 641 * @tc.require: issue 642 */ 643 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00001, Function | SmallTest | Level1) 644 { 645 struct tm nowTime; 646 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 647 EXPECT_NE(nullptr, calendar); 648 649 uint8_t day = 1; 650 bool isSet = false; 651 calendar->SetDay(day, isSet); 652 653 uint8_t month = 1; 654 calendar->SetMonth(month, isSet); 655 656 std::vector<uint8_t> repeatDaysOfWeek; 657 repeatDaysOfWeek.push_back(1); 658 calendar->SetRepeatDaysOfWeek(isSet, repeatDaysOfWeek); 659 660 auto rrc = std::make_shared<ReminderRequest>(); 661 rrc->SetSnoozeTimes(0); 662 EXPECT_EQ(rrc->GetSnoozeTimes(), 0) << "Get snoozeTimes not 1"; 663 664 uint32_t minTimeIntervalInSecond = 0; 665 rrc->SetTimeInterval(0); 666 EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond); 667 668 bool result2 = calendar->IsRepeatReminder(); 669 EXPECT_EQ(result2, false); 670 671 uint32_t ret = calendar->GetRepeatDay(); 672 uint16_t ret2 = calendar->GetRepeatMonth(); 673 uint8_t ret3 = calendar->GetRepeatMonth(); 674 EXPECT_EQ(ret, 0); 675 EXPECT_EQ(ret2, 0); 676 EXPECT_EQ(ret3, 0); 677 678 bool result3 = calendar->UpdateNextReminder(); 679 EXPECT_EQ(result3, false); 680 } 681 682 /** 683 * @tc.name: UpdateNextReminder_00002 684 * @tc.desc: Test UpdateNextReminder parameters. 685 * @tc.type: FUNC 686 * @tc.require: issue 687 */ 688 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00002, Function | SmallTest | Level1) 689 { 690 struct tm nowTime; 691 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 692 EXPECT_NE(nullptr, calendar); 693 694 uint8_t day = 2; 695 bool isSet = true; 696 calendar->SetDay(day, isSet); 697 bool result = calendar->IsRepeatDay(day); 698 EXPECT_EQ(result, true); 699 700 uint8_t month = 2; 701 calendar->SetMonth(month, isSet); 702 bool result1 = calendar->IsRepeatMonth(month); 703 EXPECT_EQ(result1, true); 704 705 bool result2 = calendar->IsRepeatReminder(); 706 EXPECT_EQ(result2, true); 707 708 auto rrc = std::make_shared<ReminderRequest>(); 709 rrc->SetSnoozeTimes(1); 710 EXPECT_EQ(rrc->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1"; 711 EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 1) << "Get snoozeTimesDynamic not 1"; 712 713 uint32_t minTimeIntervalInSecond = 5 * 60; 714 rrc->SetTimeInterval(1); 715 EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond); 716 717 bool result3 = calendar->UpdateNextReminder(); 718 EXPECT_EQ(result3, true); 719 } 720 721 /** 722 * @tc.name: UpdateNextReminder_00003 723 * @tc.desc: Test UpdateNextReminder parameters. 724 * @tc.type: FUNC 725 * @tc.require: issue 726 */ 727 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00003, Function | SmallTest | Level1) 728 { 729 struct tm nowTime; 730 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 731 EXPECT_NE(nullptr, calendar); 732 733 uint8_t day = 1; 734 bool isSet = false; 735 calendar->SetDay(day, isSet); 736 737 uint8_t month = 2; 738 bool isSet1 = true; 739 calendar->SetMonth(month, isSet1); 740 741 std::vector<uint8_t> daysOfWeek; 742 daysOfWeek.push_back(1); 743 calendar->SetRepeatDaysOfWeek(isSet, daysOfWeek); 744 745 auto rrc = std::make_shared<ReminderRequest>(); 746 rrc->SetSnoozeTimesDynamic(0); 747 EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 0); 748 749 rrc->SetSnoozeTimes(1); 750 EXPECT_EQ(rrc->GetSnoozeTimes(), 1); 751 uint32_t minTimeIntervalInSecond = 5 * 60; 752 rrc->SetTimeInterval(1); 753 EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond); 754 755 uint32_t ret = calendar->GetRepeatDay(); 756 uint16_t ret2 = calendar->GetRepeatMonth(); 757 uint16_t ret3 = 3; 758 EXPECT_EQ(ret, 0); 759 EXPECT_EQ(ret2, ret3); 760 761 bool result3 = calendar->UpdateNextReminder(); 762 EXPECT_EQ(result3, false); 763 } 764 765 /** 766 * @tc.name: UpdateNextReminder_00004 767 * @tc.desc: Test UpdateNextReminder parameters. 768 * @tc.type: FUNC 769 * @tc.require: issue 770 */ 771 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00004, Function | SmallTest | Level1) 772 { 773 struct tm nowTime; 774 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 775 EXPECT_NE(nullptr, calendar); 776 777 uint8_t day = 1; 778 bool isSet = false; 779 calendar->SetDay(day, isSet); 780 bool result = calendar->IsRepeatDay(day); 781 EXPECT_EQ(result, false); 782 783 uint8_t month = 1; 784 calendar->SetMonth(month, isSet); 785 bool result7 = calendar->IsRepeatMonth(month); 786 EXPECT_EQ(result7, false); 787 788 std::vector<uint8_t> daysOfWeek; 789 daysOfWeek.push_back(1); 790 calendar->SetRepeatDaysOfWeek(isSet, daysOfWeek); 791 bool result2 = calendar->IsRepeatDaysOfWeek(1); 792 EXPECT_EQ(result2, false); 793 794 auto reminderRequest = std::make_shared<ReminderRequest>(); 795 reminderRequest->SetSnoozeTimes(1); 796 EXPECT_EQ(reminderRequest->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1"; 797 798 reminderRequest->SetSnoozeTimesDynamic(0); 799 EXPECT_EQ(reminderRequest->GetSnoozeTimesDynamic(), 0) << "Get snoozeTimesDynamic not 1"; 800 801 uint32_t minTimeIntervalInSeconds = 5 * 60; 802 reminderRequest->SetTimeInterval(1); 803 EXPECT_EQ(reminderRequest->GetTimeInterval(), minTimeIntervalInSeconds); 804 805 bool result6 = calendar->UpdateNextReminder(); 806 EXPECT_EQ(result6, false); 807 } 808 809 /** 810 * @tc.name: UpdateNextReminder_00005 811 * @tc.desc: Test UpdateNextReminder parameters. 812 * @tc.type: FUNC 813 * @tc.require: issue 814 */ 815 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00005, Function | SmallTest | Level1) 816 { 817 struct tm nowTime; 818 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 819 EXPECT_NE(nullptr, calendar); 820 821 uint8_t day = 2; 822 bool isSet = true; 823 calendar->SetDay(day, isSet); 824 bool result = calendar->IsRepeatDay(day); 825 EXPECT_EQ(result, true); 826 827 uint8_t month = 1; 828 bool isSet1 = false; 829 calendar->SetMonth(month, isSet1); 830 bool result1 = calendar->IsRepeatMonth(month); 831 EXPECT_EQ(result1, false); 832 833 std::vector<uint8_t> daysOfWeek; 834 daysOfWeek.push_back(1); 835 calendar->SetRepeatDaysOfWeek(isSet1, daysOfWeek); 836 837 auto rrc = std::make_shared<ReminderRequest>(); 838 rrc->SetSnoozeTimes(1); 839 EXPECT_EQ(rrc->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1"; 840 841 rrc->SetSnoozeTimesDynamic(0); 842 EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 0) << "Get snoozeTimesDynamic not 1"; 843 844 uint32_t minTimeIntervalInSecond = 5 * 60; 845 rrc->SetTimeInterval(1); 846 EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond); 847 848 bool result3 = calendar->UpdateNextReminder(); 849 EXPECT_EQ(result3, false); 850 } 851 852 /** 853 * @tc.name: UpdateNextReminder_00006 854 * @tc.desc: Test UpdateNextReminder parameters. 855 * @tc.type: FUNC 856 * @tc.require: I8CZ6P 857 */ 858 HWTEST_F(ReminderRequestCalendarTest, UpdateNextReminder_00006, Function | SmallTest | Level1) 859 { 860 struct tm nowTime; 861 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 862 EXPECT_NE(nullptr, calendar); 863 864 uint8_t day = 2; 865 bool isSet = false; 866 bool isSet1 = true; 867 calendar->SetDay(day, isSet); 868 bool result = calendar->IsRepeatDay(day); 869 EXPECT_EQ(result, false); 870 871 uint8_t month = 2; 872 calendar->SetMonth(month, isSet); 873 bool result1 = calendar->IsRepeatMonth(month); 874 EXPECT_EQ(result1, false); 875 876 std::vector<uint8_t> daysOfWeek; 877 daysOfWeek.push_back(1); 878 daysOfWeek.push_back(3); 879 daysOfWeek.push_back(4); 880 daysOfWeek.push_back(5); 881 daysOfWeek.push_back(6); 882 calendar->SetRepeatDaysOfWeek(isSet1, daysOfWeek); 883 884 bool result2 = calendar->IsRepeatDaysOfWeek(1); 885 EXPECT_EQ(result2, true); 886 887 bool result3 = calendar->IsRepeatReminder(); 888 EXPECT_EQ(result3, true); 889 890 auto rrc = std::make_shared<ReminderRequest>(); 891 rrc->SetSnoozeTimes(1); 892 EXPECT_EQ(rrc->GetSnoozeTimes(), 1) << "Get snoozeTimes not 1"; 893 EXPECT_EQ(rrc->GetSnoozeTimesDynamic(), 1) << "Get snoozeTimesDynamic not 1"; 894 895 uint32_t minTimeIntervalInSecond = 5 * 60; 896 rrc->SetTimeInterval(1); 897 EXPECT_EQ(rrc->GetTimeInterval(), minTimeIntervalInSecond); 898 899 bool result4 = calendar->UpdateNextReminder(); 900 EXPECT_EQ(result4, true); 901 902 uint16_t ret2 = calendar->GetRepeatDaysOfWeek(); 903 uint16_t ret3 = 61; 904 EXPECT_EQ(ret2, ret3); 905 } 906 907 /** 908 * @tc.name: SetRepeatMonths_00001 909 * @tc.desc: Test SetRepeatMonths parameters. 910 * @tc.type: FUNC 911 * @tc.require: issue 912 */ 913 HWTEST_F(ReminderRequestCalendarTest, SetRepeatMonths_00001, Function | SmallTest | Level1) 914 { 915 struct tm nowTime; 916 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 917 EXPECT_NE(nullptr, calendar); 918 919 uint8_t arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; 920 std::vector<uint8_t> repeatMonths (arr, arr + sizeof(arr) / sizeof(uint8_t)); 921 calendar->SetRepeatMonths(repeatMonths); 922 uint8_t ret = 13; 923 EXPECT_EQ(repeatMonths.size(), ret); 924 } 925 926 /** 927 * @tc.name: RecoverFromDb_00001 928 * @tc.desc: Test RecoverFromDb parameters. 929 * @tc.type: FUNC 930 * @tc.require: issue 931 */ 932 HWTEST_F(ReminderRequestCalendarTest, RecoverFromDb_00001, Function | SmallTest | Level1) 933 { 934 struct tm nowTime; 935 auto calendar = ReminderRequestCalendarTest::CreateCalendar(nowTime); 936 EXPECT_NE(nullptr, calendar); 937 938 std::shared_ptr<NativeRdb::ResultSet> resultSet = 939 std::make_shared<NativeRdb::AbsSharedResultSet>(); 940 calendar->RecoverFromDb(resultSet); 941 bool result = calendar->IsRepeatDay(1); 942 EXPECT_EQ(result, false); 943 } 944 } 945 }