1 /* 2 * Copyright (c) 2022 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_store.h" 19 #include "reminder_table.h" 20 #include "reminder_table_old.h" 21 #include "reminder_request_alarm.h" 22 #include "reminder_request_calendar.h" 23 #include "reminder_request_timer.h" 24 #include "reminder_helper.h" 25 #include "reminder_store_strategy.h" 26 #include "abs_shared_result_set.h" 27 28 using namespace testing::ext; 29 namespace OHOS { 30 namespace Notification { 31 namespace { 32 constexpr int32_t NON_SYSTEM_APP_UID = 1000; 33 const std::string TEST_DEFUALT_BUNDLE = "bundleName"; 34 const int32_t STATE_FAIL = -1; 35 } 36 class ReminderStoreTest : public testing::Test { 37 public: SetUpTestCase()38 static void SetUpTestCase() 39 { 40 ReminderHelper::CancelAllReminders(); 41 } TearDownTestCase()42 static void TearDownTestCase() {} SetUp()43 void SetUp() {} TearDown()44 void TearDown() 45 { 46 ReminderHelper::CancelAllReminders(); 47 NativeRdb::RdbHelper::DeleteRdbStore(ReminderStore::REMINDER_DB_DIR + ReminderStore::REMINDER_DB_NAME); 48 } 49 InitStore(ReminderStore & store)50 void InitStore(ReminderStore& store) 51 { 52 std::string dbConfig = ReminderStore::REMINDER_DB_DIR + "notification_test.db"; 53 NativeRdb::RdbStoreConfig config(dbConfig); 54 config.SetSecurityLevel(NativeRdb::SecurityLevel::S1); 55 { 56 ReminderStore::ReminderStoreDataCallBack rdbDataCallBack; 57 int32_t errCode = STATE_FAIL; 58 constexpr int32_t version = 7; 59 store.rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, version, rdbDataCallBack, errCode); 60 } 61 } 62 ClearStore()63 void ClearStore() 64 { 65 NativeRdb::RdbHelper::ClearCache(); 66 NativeRdb::RdbHelper::DeleteRdbStore(ReminderStore::REMINDER_DB_DIR + "notification_test.db"); 67 } 68 }; 69 70 71 /** 72 * @tc.name: Init_00001 73 * @tc.desc: Test Init parameters. 74 * @tc.type: FUNC 75 * @tc.require: issueI5VB6V 76 */ 77 HWTEST_F(ReminderStoreTest, Init_00001, Function | SmallTest | Level1) 78 { 79 ReminderStore reminderStore; 80 int32_t ret = reminderStore.Init(); 81 EXPECT_EQ(ret, 0); 82 } 83 84 /** 85 * @tc.name: InitData_00001 86 * @tc.desc: Test InitData parameters. 87 * @tc.type: FUNC 88 * @tc.require: issueI5VB6V 89 */ 90 HWTEST_F(ReminderStoreTest, InitData_00001, Function | SmallTest | Level1) 91 { 92 ReminderStore reminderStore; 93 int32_t ret = reminderStore.InitData(); 94 EXPECT_EQ(ret, -1); 95 } 96 97 /** 98 * @tc.name: Delete_00001 99 * @tc.desc: Test Delete parameters. 100 * @tc.type: FUNC 101 * @tc.require: issueI5VB6V 102 */ 103 HWTEST_F(ReminderStoreTest, Delete_00001, Function | SmallTest | Level1) 104 { 105 int32_t reminderId = 1; 106 ReminderStore reminderStore; 107 int32_t ret = reminderStore.Delete(reminderId); 108 EXPECT_EQ(ret, -1); 109 } 110 111 /** 112 * @tc.name: Delete_00002 113 * @tc.desc: Test Delete parameters. 114 * @tc.type: FUNC 115 * @tc.require: issueI5VB6V 116 */ 117 HWTEST_F(ReminderStoreTest, Delete_00002, Function | SmallTest | Level1) 118 { 119 int32_t userId = 1; 120 ReminderStore reminderStore; 121 int32_t ret = reminderStore.Delete("", userId, -1); 122 EXPECT_EQ(ret, -1); 123 } 124 125 /** 126 * @tc.name: Delete_00003 127 * @tc.desc: Test Delete parameters. 128 * @tc.type: FUNC 129 * @tc.require: issueI5VB6V 130 */ 131 HWTEST_F(ReminderStoreTest, Delete_00003, Function | SmallTest | Level1) 132 { 133 std::string deleteCondition = "deleteCondition"; 134 ReminderStore reminderStore; 135 int32_t ret = reminderStore.DeleteBase(deleteCondition); 136 EXPECT_EQ(ret, -1); 137 } 138 139 /** 140 * @tc.name: Insert_00001 141 * @tc.desc: Test Insert parameters. 142 * @tc.type: FUNC 143 * @tc.require: issueI5VB6V 144 */ 145 HWTEST_F(ReminderStoreTest, Insert_00001, Function | SmallTest | Level1) 146 { 147 sptr<ReminderRequest> reminder = nullptr; 148 ReminderStore reminderStore; 149 int64_t ret = reminderStore.Insert(reminder); 150 EXPECT_EQ(ret, -1); 151 } 152 153 /** 154 * @tc.name: Update_00001 155 * @tc.desc: Test Update parameters. 156 * @tc.type: FUNC 157 * @tc.require: issueI5VB6V 158 */ 159 HWTEST_F(ReminderStoreTest, Update_00001, Function | SmallTest | Level1) 160 { 161 sptr<ReminderRequest> reminder = nullptr; 162 ReminderStore reminderStore; 163 int64_t ret = reminderStore.Update(reminder); 164 EXPECT_EQ(ret, -1); 165 } 166 167 /** 168 * @tc.name: Query_00001 169 * @tc.desc: Test Query parameters. 170 * @tc.type: FUNC 171 * @tc.require: issueI5VB6V 172 */ 173 HWTEST_F(ReminderStoreTest, Query_00001, Function | SmallTest | Level1) 174 { 175 std::string queryCondition = "queryCondition"; 176 std::string name = "it"; 177 ReminderStore reminderStore; 178 std::shared_ptr<NativeRdb::ResultSet> ret = reminderStore.Query(queryCondition); 179 EXPECT_EQ(ret, nullptr); 180 } 181 182 /** 183 * @tc.name: GetMaxId_00001 184 * @tc.desc: Test GetMaxId parameters. 185 * @tc.type: FUNC 186 * @tc.require: issueI5VB6V 187 */ 188 HWTEST_F(ReminderStoreTest, GetMaxId_00001, Function | SmallTest | Level1) 189 { 190 ReminderStore reminderStore; 191 int32_t ret = reminderStore.GetMaxId(); 192 EXPECT_EQ(ret, STATE_FAIL); 193 } 194 195 /** 196 * @tc.name: GetAllValidReminders_00001 197 * @tc.desc: Test GetAllValidReminders parameters. 198 * @tc.type: FUNC 199 * @tc.require: issueI5VB6V 200 */ 201 HWTEST_F(ReminderStoreTest, GetAllValidReminders_00001, Function | SmallTest | Level1) 202 { 203 ReminderStore reminderStore; 204 std::vector<sptr<ReminderRequest>> ret = reminderStore.GetAllValidReminders(); 205 EXPECT_EQ(ret.size(), 0); 206 } 207 208 /** 209 * @tc.name: GetReminders_00001 210 * @tc.desc: Test GetReminders parameters. 211 * @tc.type: FUNC 212 * @tc.require: issueI5VB6V 213 */ 214 HWTEST_F(ReminderStoreTest, GetReminders_00001, Function | SmallTest | Level1) 215 { 216 std::string queryCondition = "queryCondition"; 217 ReminderStore reminderStore; 218 std::vector<sptr<ReminderRequest>> ret = reminderStore.GetReminders(queryCondition); 219 EXPECT_EQ(ret.size(), 0); 220 } 221 222 /** 223 * @tc.name: Query_00002 224 * @tc.desc: Test Query parameters. 225 * @tc.type: FUNC 226 * @tc.require: issueI92BU9 227 */ 228 HWTEST_F(ReminderStoreTest, Query_00002, Function | SmallTest | Level1) 229 { 230 std::string tableName = "reminder_base"; 231 std::string colums = "reminder_type"; 232 int32_t reminderId = 0; 233 ReminderStore reminderStore; 234 std::shared_ptr<NativeRdb::ResultSet> ret = reminderStore.Query(tableName, 235 colums, reminderId); 236 EXPECT_EQ(ret, nullptr); 237 } 238 239 /** 240 * @tc.name: Delete_00004 241 * @tc.desc: Test Delete parameters. 242 * @tc.type: FUNC 243 * @tc.require: issueI92BU9 244 */ 245 HWTEST_F(ReminderStoreTest, Delete_00004, Function | SmallTest | Level1) 246 { 247 std::string conditiont1 = "deleteCondition1"; 248 std::string conditiont2 = "deleteCondition2"; 249 ReminderStore reminderStore; 250 int32_t ret = reminderStore.Delete(conditiont1, conditiont2); 251 EXPECT_EQ(ret, -1); 252 } 253 254 /** 255 * @tc.name: DeleteUser_00004 256 * @tc.desc: Test DeleteUser parameters. 257 * @tc.type: FUNC 258 * @tc.require: issueI92BU9 259 */ 260 HWTEST_F(ReminderStoreTest, DeleteUser_00004, Function | SmallTest | Level1) 261 { 262 int32_t userId = 0; 263 ReminderStore reminderStore; 264 int32_t ret = reminderStore.DeleteUser(userId); 265 EXPECT_EQ(ret, -1); 266 } 267 268 /** 269 * @tc.name: UpdateOrInsert_00001 270 * @tc.desc: Test UpdateOrInsert parameters. 271 * @tc.type: FUNC 272 * @tc.require: issueI92BU9 273 */ 274 HWTEST_F(ReminderStoreTest, UpdateOrInsert_00001, Function | SmallTest | Level1) 275 { 276 sptr<ReminderRequest> reminder = nullptr; 277 ReminderStore reminderStore; 278 int64_t ret = reminderStore.UpdateOrInsert(reminder); 279 EXPECT_EQ(ret, -1); 280 } 281 282 /** 283 * @tc.name: OnCreate_00001 284 * @tc.desc: Test OnCreate parameters. 285 * @tc.type: FUNC 286 * @tc.require: issueI92BU9 287 */ 288 HWTEST_F(ReminderStoreTest, OnCreate_00001, Function | SmallTest | Level1) 289 { 290 std::string dbConfig = ReminderStore::REMINDER_DB_DIR + "notification_test.db"; 291 NativeRdb::RdbStoreConfig config(dbConfig); 292 config.SetSecurityLevel(NativeRdb::SecurityLevel::S1); 293 { 294 ReminderStore::ReminderStoreDataCallBack rdbDataCallBack; 295 int32_t errCode = STATE_FAIL; 296 auto rdbStore = NativeRdb::RdbHelper::GetRdbStore(config, 5, rdbDataCallBack, errCode); 297 EXPECT_NE(rdbStore, nullptr); 298 } 299 NativeRdb::RdbHelper::ClearCache(); 300 NativeRdb::RdbHelper::DeleteRdbStore(ReminderStore::REMINDER_DB_DIR + "notification_test.db"); 301 } 302 303 /** 304 * @tc.name: Delete_00005 305 * @tc.desc: Test OnCreate parameters. 306 * @tc.type: FUNC 307 * @tc.require: issueI92BU9 308 */ 309 HWTEST_F(ReminderStoreTest, Delete_00005, Function | SmallTest | Level1) 310 { 311 ReminderStore reminderStore; 312 int32_t ret = reminderStore.Delete("com.example.simple", 100, 20020152); 313 EXPECT_EQ(ret, -1); 314 315 ret = reminderStore.Delete("com.example.simple", 100, -1); 316 EXPECT_EQ(ret, -1); 317 } 318 319 /** 320 * @tc.name: ReminderStrategyTest_00001 321 * @tc.desc: Test OnCreate parameters. 322 * @tc.type: FUNC 323 * @tc.require: issueI92BU9 324 */ 325 HWTEST_F(ReminderStoreTest, ReminderTimerStrategyTest_00001, Function | SmallTest | Level1) 326 { 327 ReminderStore reminderStore; 328 InitStore(reminderStore); 329 sptr<ReminderRequest> reminder = new ReminderRequestTimer(); 330 reminder->reminderId_ = 999; 331 reminder->bundleName_ = "ReminderTimerStrategyTest_00001"; 332 reminder->userId_ = 998; 333 reminder->uid_ = 997; 334 reminder->isSystemApp_ = true; 335 reminder->reminderType_ = ReminderRequest::ReminderType::TIMER; 336 reminder->reminderTimeInMilli_ = 123456789; 337 reminder->triggerTimeInMilli_ = 987654321; 338 reminder->SetTimeInterval(100); 339 reminder->snoozeTimes_ = 10; 340 reminder->snoozeTimesDynamic_ = 9; 341 reminder->SetRingDuration(500); 342 reminder->isExpired_ = false; 343 reminder->state_ = 123; 344 ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr()); 345 timer->countDownTimeInSeconds_ = 10001; 346 347 reminderStore.UpdateOrInsert(reminder); 348 auto reminders = reminderStore.GetAllValidReminders(); 349 bool succeed = false; 350 for (auto each : reminders) { 351 if (each->reminderId_ != reminder->reminderId_) { 352 continue; 353 } 354 355 EXPECT_EQ(reminder->bundleName_, each->bundleName_); 356 EXPECT_EQ(reminder->userId_, each->userId_); 357 EXPECT_EQ(reminder->uid_, each->uid_); 358 EXPECT_EQ(reminder->isSystemApp_, each->isSystemApp_); 359 EXPECT_EQ(reminder->reminderType_, each->reminderType_); 360 EXPECT_EQ(reminder->reminderTimeInMilli_, each->reminderTimeInMilli_); 361 EXPECT_EQ(reminder->triggerTimeInMilli_, each->triggerTimeInMilli_); 362 EXPECT_EQ(reminder->GetTimeInterval(), each->GetTimeInterval()); 363 EXPECT_EQ(reminder->snoozeTimes_, each->snoozeTimes_); 364 EXPECT_EQ(reminder->snoozeTimesDynamic_, each->snoozeTimesDynamic_); 365 EXPECT_EQ(reminder->GetRingDuration(), each->GetRingDuration()); 366 EXPECT_EQ(reminder->isExpired_, each->isExpired_); 367 EXPECT_EQ(reminder->state_, each->state_); 368 ReminderRequestTimer* timer1 = static_cast<ReminderRequestTimer*>(each.GetRefPtr()); 369 EXPECT_EQ(timer1->countDownTimeInSeconds_, timer->countDownTimeInSeconds_); 370 succeed = true; 371 break; 372 } 373 reminderStore.Delete(reminder->reminderId_); 374 EXPECT_EQ(succeed, true); 375 ClearStore(); 376 } 377 378 /** 379 * @tc.name: ReminderTimerStrategyTest_00002 380 * @tc.desc: Test OnCreate parameters. 381 * @tc.type: FUNC 382 * @tc.require: issueI92BU9 383 */ 384 HWTEST_F(ReminderStoreTest, ReminderTimerStrategyTest_00002, Function | SmallTest | Level1) 385 { 386 ReminderStore reminderStore; 387 InitStore(reminderStore); 388 sptr<ReminderRequest> reminder = new ReminderRequestTimer(); 389 reminder->reminderId_ = 999; 390 reminder->reminderType_ = ReminderRequest::ReminderType::TIMER; 391 reminder->slotType_ = static_cast<NotificationConstant::SlotType>(1); 392 reminder->snoozeSlotType_ = static_cast<NotificationConstant::SlotType>(1); 393 reminder->notificationId_ = 123; 394 reminder->title_ = "title_"; 395 reminder->content_ = "content_"; 396 reminder->snoozeContent_ = "snoozeContent_"; 397 reminder->expiredContent_ = "expiredContent_"; 398 reminder->tapDismissed_ = false; 399 reminder->autoDeletedTime_ = 666; 400 reminder->groupId_ = "groupId_"; 401 reminder->customRingUri_ = "customRingUri_"; 402 reminder->creatorBundleName_ = "creatorBundleName_"; 403 reminder->creatorUid_ = 101; 404 ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr()); 405 timer->countDownTimeInSeconds_ = 10001; 406 407 reminderStore.UpdateOrInsert(reminder); 408 auto reminders = reminderStore.GetAllValidReminders(); 409 bool succeed = false; 410 for (auto each : reminders) { 411 if (each->reminderId_ != reminder->reminderId_) { 412 continue; 413 } 414 415 EXPECT_EQ(reminder->slotType_, each->slotType_); 416 EXPECT_EQ(reminder->snoozeSlotType_, each->snoozeSlotType_); 417 EXPECT_EQ(reminder->notificationId_, each->notificationId_); 418 EXPECT_EQ(reminder->title_, each->title_); 419 EXPECT_EQ(reminder->content_, each->content_); 420 EXPECT_EQ(reminder->snoozeContent_, each->snoozeContent_); 421 EXPECT_EQ(reminder->expiredContent_, each->expiredContent_); 422 EXPECT_EQ(reminder->tapDismissed_, each->tapDismissed_); 423 EXPECT_EQ(reminder->autoDeletedTime_, each->autoDeletedTime_); 424 EXPECT_EQ(reminder->groupId_, each->groupId_); 425 EXPECT_EQ(reminder->customRingUri_, each->customRingUri_); 426 EXPECT_EQ(reminder->creatorBundleName_, each->creatorBundleName_); 427 EXPECT_EQ(reminder->creatorUid_, each->creatorUid_); 428 succeed = true; 429 break; 430 } 431 reminderStore.Delete(reminder->reminderId_); 432 EXPECT_EQ(succeed, true); 433 ClearStore(); 434 } 435 436 /** 437 * @tc.name: ReminderTimerStrategyTest_00003 438 * @tc.desc: Test OnCreate parameters. 439 * @tc.type: FUNC 440 * @tc.require: issueI92BU9 441 */ 442 HWTEST_F(ReminderStoreTest, ReminderTimerStrategyTest_00003, Function | SmallTest | Level1) 443 { 444 ReminderStore reminderStore; 445 InitStore(reminderStore); 446 sptr<ReminderRequest> reminder = new ReminderRequestTimer(); 447 reminder->reminderId_ = 999; 448 reminder->reminderType_ = ReminderRequest::ReminderType::TIMER; 449 reminder->customButtonUri_ = "customButtonUri_"; 450 if (reminder->wantAgentInfo_ == nullptr) { 451 reminder->InitServerObj(); 452 } 453 reminder->wantAgentInfo_->pkgName = "pkgName"; 454 reminder->wantAgentInfo_->abilityName = "abilityName"; 455 reminder->wantAgentInfo_->uri = "uri"; 456 reminder->maxScreenWantAgentInfo_->pkgName = "pkgName1"; 457 reminder->maxScreenWantAgentInfo_->abilityName = "abilityName1"; 458 ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr()); 459 timer->countDownTimeInSeconds_ = 10001; 460 461 reminderStore.UpdateOrInsert(reminder); 462 auto reminders = reminderStore.GetAllValidReminders(); 463 bool succeed = false; 464 for (auto each : reminders) { 465 if (each->reminderId_ != reminder->reminderId_) { 466 continue; 467 } 468 469 EXPECT_EQ(reminder->customButtonUri_, each->customButtonUri_); 470 EXPECT_EQ(reminder->wantAgentInfo_->pkgName, each->wantAgentInfo_->pkgName); 471 EXPECT_EQ(reminder->wantAgentInfo_->abilityName, each->wantAgentInfo_->abilityName); 472 EXPECT_EQ(reminder->wantAgentInfo_->uri, each->wantAgentInfo_->uri); 473 EXPECT_EQ(reminder->maxScreenWantAgentInfo_->pkgName, each->maxScreenWantAgentInfo_->pkgName); 474 EXPECT_EQ(reminder->maxScreenWantAgentInfo_->abilityName, each->maxScreenWantAgentInfo_->abilityName); 475 succeed = true; 476 break; 477 } 478 reminderStore.Delete(reminder->reminderId_); 479 EXPECT_EQ(succeed, true); 480 ClearStore(); 481 } 482 483 /** 484 * @tc.name: ReminderAlarmStrategyTest_00001 485 * @tc.desc: Test OnCreate parameters. 486 * @tc.type: FUNC 487 * @tc.require: issueI92BU9 488 */ 489 HWTEST_F(ReminderStoreTest, ReminderAlarmStrategyTest_00001, Function | SmallTest | Level1) 490 { 491 ReminderStore reminderStore; 492 InitStore(reminderStore); 493 sptr<ReminderRequest> reminder = new ReminderRequestAlarm(); 494 reminder->reminderId_ = 999; 495 reminder->reminderType_ = ReminderRequest::ReminderType::ALARM; 496 reminder->repeatDaysOfWeek_ = 55; 497 ReminderRequestAlarm* alarm = static_cast<ReminderRequestAlarm*>(reminder.GetRefPtr()); 498 alarm->hour_ = 12; 499 alarm->minute_ = 30; 500 501 reminderStore.UpdateOrInsert(reminder); 502 auto reminders = reminderStore.GetAllValidReminders(); 503 bool succeed = false; 504 for (auto each : reminders) { 505 if (each->reminderId_ != reminder->reminderId_) { 506 continue; 507 } 508 509 EXPECT_EQ(reminder->repeatDaysOfWeek_, each->repeatDaysOfWeek_); 510 ReminderRequestAlarm* alarm1 = static_cast<ReminderRequestAlarm*>(each.GetRefPtr()); 511 EXPECT_EQ(alarm->hour_, alarm1->hour_); 512 EXPECT_EQ(alarm->minute_, alarm1->minute_); 513 succeed = true; 514 break; 515 } 516 reminderStore.Delete(reminder->reminderId_); 517 EXPECT_EQ(succeed, true); 518 ClearStore(); 519 } 520 521 /** 522 * @tc.name: ReminderCalendarStrategyTest_00001 523 * @tc.desc: Test OnCreate parameters. 524 * @tc.type: FUNC 525 * @tc.require: issueI92BU9 526 */ 527 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00001, Function | SmallTest | Level1) 528 { 529 ReminderStore reminderStore; 530 InitStore(reminderStore); 531 time_t t; 532 (void)time(&t); // unit is seconds. 533 uint64_t ts = t * 1000; // ms 534 535 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(); 536 reminder->reminderId_ = 999; 537 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR; 538 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr()); 539 calendar->firstDesignateYear_ = 2006; 540 calendar->firstDesignateMonth_ = 6; 541 calendar->firstDesignateDay_ = 6; 542 calendar->SetDateTime(ts); 543 calendar->SetEndDateTime(ts + 60 * 1000); 544 calendar->SetLastStartDateTime(ts + 10 * 1000); 545 calendar->repeatDay_ = 12; 546 calendar->repeatMonth_ = 13; 547 calendar->AddExcludeDate(ts); 548 549 reminderStore.UpdateOrInsert(reminder); 550 auto reminders = reminderStore.GetAllValidReminders(); 551 bool succeed = false; 552 for (auto each : reminders) { 553 if (each->reminderId_ != reminder->reminderId_) { 554 continue; 555 } 556 557 ReminderRequestCalendar* calendar1 = static_cast<ReminderRequestCalendar*>(each.GetRefPtr()); 558 EXPECT_EQ(calendar1->firstDesignateYear_, calendar->firstDesignateYear_); 559 EXPECT_EQ(calendar1->firstDesignateMonth_, calendar->firstDesignateMonth_); 560 EXPECT_EQ(calendar1->firstDesignateDay_, calendar->firstDesignateDay_); 561 EXPECT_EQ(calendar1->repeatDay_, calendar->repeatDay_); 562 EXPECT_EQ(calendar1->repeatMonth_, calendar->repeatMonth_); 563 EXPECT_EQ(calendar1->GetDateTime(), calendar->GetDateTime()); 564 EXPECT_EQ(calendar1->GetEndDateTime(), calendar->GetEndDateTime()); 565 EXPECT_EQ(calendar1->GetLastStartDateTime(), calendar->GetLastStartDateTime()); 566 EXPECT_EQ(calendar1->SerializationExcludeDates(), calendar->SerializationExcludeDates()); 567 EXPECT_EQ(calendar1->SerializationRRule(), calendar->SerializationRRule()); 568 succeed = true; 569 break; 570 } 571 reminderStore.Delete(reminder->reminderId_); 572 EXPECT_EQ(succeed, true); 573 ClearStore(); 574 } 575 576 /** 577 * @tc.name: ReminderCalendarStrategyTest_00002 578 * @tc.desc: Test OnCreate parameters. 579 * @tc.type: FUNC 580 * @tc.require: issueI92BU9 581 */ 582 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00002, Function | SmallTest | Level1) 583 { 584 ReminderStore reminderStore; 585 InitStore(reminderStore); 586 time_t t; 587 (void)time(&t); // unit is seconds. 588 uint64_t ts = t * 1000; // ms 589 590 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(); 591 reminder->SetShare(true); 592 reminderStore.UpdateOrInsert(reminder); 593 reminder->SetShare(false); 594 reminder->reminderId_ = 999; 595 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR; 596 reminder->repeatDaysOfWeek_ = 55; 597 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr()); 598 calendar->SetDateTime(ts); 599 calendar->rruleWantAgentInfo_ = std::make_shared<ReminderRequest::WantAgentInfo>(); 600 calendar->rruleWantAgentInfo_->pkgName = "pkgName"; 601 calendar->rruleWantAgentInfo_->abilityName = "abilityName"; 602 calendar->rruleWantAgentInfo_->uri = "uri"; 603 604 reminderStore.UpdateOrInsert(reminder); 605 auto reminders = reminderStore.GetAllValidReminders(); 606 bool succeed = false; 607 for (auto each : reminders) { 608 if (each->reminderId_ != reminder->reminderId_) { 609 continue; 610 } 611 612 EXPECT_EQ(reminder->repeatDaysOfWeek_, each->repeatDaysOfWeek_); 613 ReminderRequestCalendar* calendar1 = static_cast<ReminderRequestCalendar*>(each.GetRefPtr()); 614 EXPECT_EQ(calendar1->GetDateTime(), calendar->GetDateTime()); 615 EXPECT_EQ(calendar1->GetEndDateTime(), calendar->GetDateTime()); 616 EXPECT_EQ(calendar1->GetLastStartDateTime(), calendar->GetDateTime()); 617 EXPECT_EQ(calendar1->SerializationRRule(), calendar->SerializationRRule()); 618 succeed = true; 619 break; 620 } 621 reminderStore.Delete(reminder->reminderId_); 622 EXPECT_EQ(succeed, true); 623 ClearStore(); 624 } 625 626 /** 627 * @tc.name: ReminderCalendarStrategyTest_00003 628 * @tc.desc: Test OnCreate parameters. 629 * @tc.type: FUNC 630 * @tc.require: issueI92BU9 631 */ 632 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00003, Function | SmallTest | Level1) 633 { 634 ReminderStrategy base; 635 sptr<ReminderRequest> calendar = new ReminderRequestCalendar(); 636 calendar->reminderType_ = ReminderRequest::ReminderType::CALENDAR; 637 sptr<ReminderRequest> alarm = new ReminderRequestAlarm(); 638 alarm->reminderType_ = ReminderRequest::ReminderType::ALARM; 639 sptr<ReminderRequest> timer = new ReminderRequestTimer(); 640 timer->reminderType_ = ReminderRequest::ReminderType::TIMER; 641 NativeRdb::ValuesBucket values; 642 base.AppendValuesBucket(calendar, values, true); 643 644 std::shared_ptr<NativeRdb::ResultSet> result = std::make_shared<NativeRdb::AbsSharedResultSet>(); 645 sptr<ReminderRequest> nullReminder; 646 base.RecoverFromOldVersion(nullReminder, result); 647 base.RecoverFromOldVersion(calendar, nullptr); 648 base.RecoverFromOldVersion(calendar, result); 649 650 base.RecoverFromDb(nullReminder, result); 651 base.RecoverFromDb(calendar, nullptr); 652 base.RecoverFromDb(calendar, result); 653 654 ReminderTimerStrategy timerStrategy; 655 timerStrategy.RecoverFromOldVersion(nullReminder, result); 656 timerStrategy.RecoverFromOldVersion(calendar, nullptr); 657 timerStrategy.RecoverFromOldVersion(timer, result); 658 659 std::shared_ptr<NativeRdb::ResultSet> baseResult = std::make_shared<NativeRdb::AbsSharedResultSet>(); 660 661 timerStrategy.RecoverFromDb(nullReminder, result, baseResult); 662 timerStrategy.RecoverFromDb(calendar, nullptr, baseResult); 663 timerStrategy.RecoverFromDb(calendar, result, nullptr); 664 timerStrategy.RecoverFromDb(timer, result, baseResult); 665 666 ReminderAlarmStrategy alarmStrategy; 667 alarmStrategy.RecoverFromOldVersion(nullReminder, result); 668 alarmStrategy.RecoverFromOldVersion(calendar, nullptr); 669 alarmStrategy.RecoverFromOldVersion(alarm, result); 670 671 alarmStrategy.RecoverFromDb(nullReminder, result, baseResult); 672 alarmStrategy.RecoverFromDb(calendar, nullptr, baseResult); 673 alarmStrategy.RecoverFromDb(calendar, result, nullptr); 674 alarmStrategy.RecoverFromDb(alarm, result, baseResult); 675 676 ReminderCalendarStrategy calendarStrategy; 677 calendarStrategy.RecoverFromOldVersion(nullReminder, result); 678 calendarStrategy.RecoverFromOldVersion(alarm, nullptr); 679 calendarStrategy.RecoverFromOldVersion(calendar, result); 680 681 calendarStrategy.RecoverFromDb(nullReminder, result, baseResult); 682 calendarStrategy.RecoverFromDb(alarm, nullptr, baseResult); 683 calendarStrategy.RecoverFromDb(alarm, result, nullptr); 684 calendarStrategy.RecoverFromDb(calendar, result, baseResult); 685 EXPECT_EQ(alarm->reminderId_, 0); 686 } 687 688 /** 689 * @tc.name: ReminderCalendarStrategyTest_00004 690 * @tc.desc: Test OnCreate parameters. 691 * @tc.type: FUNC 692 * @tc.require: issueI92BU9 693 */ 694 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00004, Function | SmallTest | Level1) 695 { 696 std::shared_ptr<NativeRdb::ResultSet> result = std::make_shared<NativeRdb::AbsSharedResultSet>(); 697 int32_t value = 0; 698 ReminderStore::GetInt32Val(result, "1", value); 699 int64_t val = 0; 700 ReminderStore::GetInt64Val(result, "1", val); 701 std::string str; 702 ReminderStore::GetStringVal(result, "1", str); 703 704 ReminderStore reminderStore; 705 reminderStore.QueryActiveReminderCount(); 706 InitStore(reminderStore); 707 reminderStore.QueryActiveReminderCount(); 708 ClearStore(); 709 EXPECT_GE(value, 0); 710 } 711 } 712 }