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 reminder->ringChannel_ = ReminderRequest::RingChannel::MEDIA; 451 if (reminder->wantAgentInfo_ == nullptr) { 452 reminder->InitServerObj(); 453 } 454 reminder->wantAgentInfo_->pkgName = "pkgName"; 455 reminder->wantAgentInfo_->abilityName = "abilityName"; 456 reminder->wantAgentInfo_->uri = "uri"; 457 reminder->maxScreenWantAgentInfo_->pkgName = "pkgName1"; 458 reminder->maxScreenWantAgentInfo_->abilityName = "abilityName1"; 459 ReminderRequestTimer* timer = static_cast<ReminderRequestTimer*>(reminder.GetRefPtr()); 460 timer->countDownTimeInSeconds_ = 10001; 461 462 reminderStore.UpdateOrInsert(reminder); 463 auto reminders = reminderStore.GetAllValidReminders(); 464 bool succeed = false; 465 for (auto each : reminders) { 466 if (each->reminderId_ != reminder->reminderId_) { 467 continue; 468 } 469 470 EXPECT_EQ(reminder->customButtonUri_, each->customButtonUri_); 471 EXPECT_EQ(reminder->ringChannel_, each->ringChannel_); 472 EXPECT_EQ(reminder->wantAgentInfo_->pkgName, each->wantAgentInfo_->pkgName); 473 EXPECT_EQ(reminder->wantAgentInfo_->abilityName, each->wantAgentInfo_->abilityName); 474 EXPECT_EQ(reminder->wantAgentInfo_->uri, each->wantAgentInfo_->uri); 475 EXPECT_EQ(reminder->maxScreenWantAgentInfo_->pkgName, each->maxScreenWantAgentInfo_->pkgName); 476 EXPECT_EQ(reminder->maxScreenWantAgentInfo_->abilityName, each->maxScreenWantAgentInfo_->abilityName); 477 succeed = true; 478 break; 479 } 480 reminderStore.Delete(reminder->reminderId_); 481 EXPECT_EQ(succeed, true); 482 ClearStore(); 483 } 484 485 /** 486 * @tc.name: ReminderAlarmStrategyTest_00001 487 * @tc.desc: Test OnCreate parameters. 488 * @tc.type: FUNC 489 * @tc.require: issueI92BU9 490 */ 491 HWTEST_F(ReminderStoreTest, ReminderAlarmStrategyTest_00001, Function | SmallTest | Level1) 492 { 493 ReminderStore reminderStore; 494 InitStore(reminderStore); 495 sptr<ReminderRequest> reminder = new ReminderRequestAlarm(); 496 reminder->reminderId_ = 999; 497 reminder->reminderType_ = ReminderRequest::ReminderType::ALARM; 498 reminder->repeatDaysOfWeek_ = 55; 499 ReminderRequestAlarm* alarm = static_cast<ReminderRequestAlarm*>(reminder.GetRefPtr()); 500 alarm->hour_ = 12; 501 alarm->minute_ = 30; 502 503 reminderStore.UpdateOrInsert(reminder); 504 auto reminders = reminderStore.GetAllValidReminders(); 505 bool succeed = false; 506 for (auto each : reminders) { 507 if (each->reminderId_ != reminder->reminderId_) { 508 continue; 509 } 510 511 EXPECT_EQ(reminder->repeatDaysOfWeek_, each->repeatDaysOfWeek_); 512 ReminderRequestAlarm* alarm1 = static_cast<ReminderRequestAlarm*>(each.GetRefPtr()); 513 EXPECT_EQ(alarm->hour_, alarm1->hour_); 514 EXPECT_EQ(alarm->minute_, alarm1->minute_); 515 succeed = true; 516 break; 517 } 518 reminderStore.Delete(reminder->reminderId_); 519 EXPECT_EQ(succeed, true); 520 ClearStore(); 521 } 522 523 /** 524 * @tc.name: ReminderCalendarStrategyTest_00001 525 * @tc.desc: Test OnCreate parameters. 526 * @tc.type: FUNC 527 * @tc.require: issueI92BU9 528 */ 529 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00001, Function | SmallTest | Level1) 530 { 531 ReminderStore reminderStore; 532 InitStore(reminderStore); 533 time_t t; 534 (void)time(&t); // unit is seconds. 535 uint64_t ts = t * 1000; // ms 536 537 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(); 538 reminder->reminderId_ = 999; 539 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR; 540 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr()); 541 calendar->firstDesignateYear_ = 2006; 542 calendar->firstDesignateMonth_ = 6; 543 calendar->firstDesignateDay_ = 6; 544 calendar->SetDateTime(ts); 545 calendar->SetEndDateTime(ts + 60 * 1000); 546 calendar->SetLastStartDateTime(ts + 10 * 1000); 547 calendar->repeatDay_ = 12; 548 calendar->repeatMonth_ = 13; 549 calendar->AddExcludeDate(ts); 550 551 reminderStore.UpdateOrInsert(reminder); 552 auto reminders = reminderStore.GetAllValidReminders(); 553 bool succeed = false; 554 for (auto each : reminders) { 555 if (each->reminderId_ != reminder->reminderId_) { 556 continue; 557 } 558 559 ReminderRequestCalendar* calendar1 = static_cast<ReminderRequestCalendar*>(each.GetRefPtr()); 560 EXPECT_EQ(calendar1->firstDesignateYear_, calendar->firstDesignateYear_); 561 EXPECT_EQ(calendar1->firstDesignateMonth_, calendar->firstDesignateMonth_); 562 EXPECT_EQ(calendar1->firstDesignateDay_, calendar->firstDesignateDay_); 563 EXPECT_EQ(calendar1->repeatDay_, calendar->repeatDay_); 564 EXPECT_EQ(calendar1->repeatMonth_, calendar->repeatMonth_); 565 EXPECT_EQ(calendar1->GetDateTime(), calendar->GetDateTime()); 566 EXPECT_EQ(calendar1->GetEndDateTime(), calendar->GetEndDateTime()); 567 EXPECT_EQ(calendar1->GetLastStartDateTime(), calendar->GetLastStartDateTime()); 568 EXPECT_EQ(calendar1->SerializationExcludeDates(), calendar->SerializationExcludeDates()); 569 EXPECT_EQ(calendar1->SerializationRRule(), calendar->SerializationRRule()); 570 succeed = true; 571 break; 572 } 573 reminderStore.Delete(reminder->reminderId_); 574 EXPECT_EQ(succeed, true); 575 ClearStore(); 576 } 577 578 /** 579 * @tc.name: ReminderCalendarStrategyTest_00002 580 * @tc.desc: Test OnCreate parameters. 581 * @tc.type: FUNC 582 * @tc.require: issueI92BU9 583 */ 584 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00002, Function | SmallTest | Level1) 585 { 586 ReminderStore reminderStore; 587 InitStore(reminderStore); 588 time_t t; 589 (void)time(&t); // unit is seconds. 590 uint64_t ts = t * 1000; // ms 591 592 sptr<ReminderRequest> reminder = new ReminderRequestCalendar(); 593 reminder->SetShare(true); 594 reminderStore.UpdateOrInsert(reminder); 595 reminder->SetShare(false); 596 reminder->reminderId_ = 999; 597 reminder->reminderType_ = ReminderRequest::ReminderType::CALENDAR; 598 reminder->repeatDaysOfWeek_ = 55; 599 ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr()); 600 calendar->SetDateTime(ts); 601 calendar->rruleWantAgentInfo_ = std::make_shared<ReminderRequest::WantAgentInfo>(); 602 calendar->rruleWantAgentInfo_->pkgName = "pkgName"; 603 calendar->rruleWantAgentInfo_->abilityName = "abilityName"; 604 calendar->rruleWantAgentInfo_->uri = "uri"; 605 606 reminderStore.UpdateOrInsert(reminder); 607 auto reminders = reminderStore.GetAllValidReminders(); 608 bool succeed = false; 609 for (auto each : reminders) { 610 if (each->reminderId_ != reminder->reminderId_) { 611 continue; 612 } 613 614 EXPECT_EQ(reminder->repeatDaysOfWeek_, each->repeatDaysOfWeek_); 615 ReminderRequestCalendar* calendar1 = static_cast<ReminderRequestCalendar*>(each.GetRefPtr()); 616 EXPECT_EQ(calendar1->GetDateTime(), calendar->GetDateTime()); 617 EXPECT_EQ(calendar1->GetEndDateTime(), calendar->GetDateTime()); 618 EXPECT_EQ(calendar1->GetLastStartDateTime(), calendar->GetDateTime()); 619 EXPECT_EQ(calendar1->SerializationRRule(), calendar->SerializationRRule()); 620 succeed = true; 621 break; 622 } 623 reminderStore.Delete(reminder->reminderId_); 624 EXPECT_EQ(succeed, true); 625 ClearStore(); 626 } 627 628 /** 629 * @tc.name: ReminderCalendarStrategyTest_00003 630 * @tc.desc: Test OnCreate parameters. 631 * @tc.type: FUNC 632 * @tc.require: issueI92BU9 633 */ 634 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00003, Function | SmallTest | Level1) 635 { 636 ReminderStrategy base; 637 sptr<ReminderRequest> calendar = new ReminderRequestCalendar(); 638 calendar->reminderType_ = ReminderRequest::ReminderType::CALENDAR; 639 sptr<ReminderRequest> alarm = new ReminderRequestAlarm(); 640 alarm->reminderType_ = ReminderRequest::ReminderType::ALARM; 641 sptr<ReminderRequest> timer = new ReminderRequestTimer(); 642 timer->reminderType_ = ReminderRequest::ReminderType::TIMER; 643 NativeRdb::ValuesBucket values; 644 base.AppendValuesBucket(calendar, values, true); 645 646 std::shared_ptr<NativeRdb::ResultSet> result = std::make_shared<NativeRdb::AbsSharedResultSet>(); 647 sptr<ReminderRequest> nullReminder; 648 base.RecoverFromOldVersion(nullReminder, result); 649 base.RecoverFromOldVersion(calendar, nullptr); 650 base.RecoverFromOldVersion(calendar, result); 651 652 base.RecoverFromDb(nullReminder, result); 653 base.RecoverFromDb(calendar, nullptr); 654 base.RecoverFromDb(calendar, result); 655 656 ReminderTimerStrategy timerStrategy; 657 timerStrategy.RecoverFromOldVersion(nullReminder, result); 658 timerStrategy.RecoverFromOldVersion(calendar, nullptr); 659 timerStrategy.RecoverFromOldVersion(timer, result); 660 661 std::shared_ptr<NativeRdb::ResultSet> baseResult = std::make_shared<NativeRdb::AbsSharedResultSet>(); 662 663 timerStrategy.RecoverFromDb(nullReminder, result, baseResult); 664 timerStrategy.RecoverFromDb(calendar, nullptr, baseResult); 665 timerStrategy.RecoverFromDb(calendar, result, nullptr); 666 timerStrategy.RecoverFromDb(timer, result, baseResult); 667 668 ReminderAlarmStrategy alarmStrategy; 669 alarmStrategy.RecoverFromOldVersion(nullReminder, result); 670 alarmStrategy.RecoverFromOldVersion(calendar, nullptr); 671 alarmStrategy.RecoverFromOldVersion(alarm, result); 672 673 alarmStrategy.RecoverFromDb(nullReminder, result, baseResult); 674 alarmStrategy.RecoverFromDb(calendar, nullptr, baseResult); 675 alarmStrategy.RecoverFromDb(calendar, result, nullptr); 676 alarmStrategy.RecoverFromDb(alarm, result, baseResult); 677 678 ReminderCalendarStrategy calendarStrategy; 679 calendarStrategy.RecoverFromOldVersion(nullReminder, result); 680 calendarStrategy.RecoverFromOldVersion(alarm, nullptr); 681 calendarStrategy.RecoverFromOldVersion(calendar, result); 682 683 calendarStrategy.RecoverFromDb(nullReminder, result, baseResult); 684 calendarStrategy.RecoverFromDb(alarm, nullptr, baseResult); 685 calendarStrategy.RecoverFromDb(alarm, result, nullptr); 686 calendarStrategy.RecoverFromDb(calendar, result, baseResult); 687 EXPECT_EQ(alarm->reminderId_, 0); 688 } 689 690 /** 691 * @tc.name: ReminderCalendarStrategyTest_00004 692 * @tc.desc: Test OnCreate parameters. 693 * @tc.type: FUNC 694 * @tc.require: issueI92BU9 695 */ 696 HWTEST_F(ReminderStoreTest, ReminderCalendarStrategyTest_00004, Function | SmallTest | Level1) 697 { 698 std::shared_ptr<NativeRdb::ResultSet> result = std::make_shared<NativeRdb::AbsSharedResultSet>(); 699 int32_t value = 0; 700 ReminderStore::GetInt32Val(result, "1", value); 701 int64_t val = 0; 702 ReminderStore::GetInt64Val(result, "1", val); 703 std::string str; 704 ReminderStore::GetStringVal(result, "1", str); 705 706 ReminderStore reminderStore; 707 reminderStore.QueryActiveReminderCount(); 708 InitStore(reminderStore); 709 reminderStore.QueryActiveReminderCount(); 710 ClearStore(); 711 EXPECT_GE(value, 0); 712 } 713 714 /** 715 * @tc.name: ReminderStoreTest_001 716 * @tc.desc: Test parameters. 717 * @tc.type: FUNC 718 * @tc.require: issueI92BU9 719 */ 720 HWTEST_F(ReminderStoreTest, ReminderStoreTest_001, Function | SmallTest | Level1) 721 { 722 ReminderStore reminderStore; 723 InitStore(reminderStore); 724 ReminderStore::ReminderStoreDataCallBack callback; 725 if (reminderStore.rdbStore_ != nullptr) { 726 NativeRdb::RdbStore& store = *reminderStore.rdbStore_.get(); 727 callback.OnCreate(store); 728 callback.OnUpgrade(store, 10, 1); 729 callback.OnUpgrade(store, 1, 2); 730 callback.OnDowngrade(store, 8, 1); 731 callback.OnUpgrade(store, 1, 9); 732 callback.OnDowngrade(store, 1, 8); 733 callback.OnDowngrade(store, 8, 7); 734 } 735 ClearStore(); 736 EXPECT_NE(reminderStore.rdbStore_, nullptr); 737 } 738 739 /** 740 * @tc.name: Update_00002 741 * @tc.desc: Test Update parameters. 742 * @tc.type: FUNC 743 * @tc.require: issueI5VB6V 744 */ 745 HWTEST_F(ReminderStoreTest, Update_00002, Function | SmallTest | Level1) 746 { 747 sptr<ReminderRequest> alarm = new ReminderRequestAlarm(10); 748 ReminderStore reminderStore; 749 InitStore(reminderStore); 750 int64_t ret = reminderStore.Update(alarm); 751 ClearStore(); 752 EXPECT_EQ(ret, 0); 753 } 754 } 755 }