1 /* 2 * Copyright (c) 2021-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 #define private public 19 #define protected public 20 #include "reminder_request_alarm.h" 21 #undef private 22 #undef protected 23 24 #include "ans_log_wrapper.h" 25 #include "reminder_helper.h" 26 27 using namespace testing::ext; 28 namespace OHOS { 29 namespace Notification { 30 class ReminderRequestAlarmTest : public testing::Test { 31 public: SetUpTestCase()32 static void SetUpTestCase() {} TearDownTestCase()33 static void TearDownTestCase() {} SetUp()34 void SetUp() {} TearDown()35 void TearDown() 36 { 37 ReminderHelper::CancelAllReminders(); 38 } 39 }; 40 41 /** 42 * @tc.name: initHour_00100 43 * @tc.desc: test set edge value of hour (0 and 23). 44 * @tc.type: FUNC 45 * @tc.require: SR000GGTRC AR000GH8E8 46 */ 47 HWTEST_F(ReminderRequestAlarmTest, initHour_00100, Function | SmallTest | Level1) 48 { 49 std::vector<uint8_t> daysOfWeek; 50 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek); 51 EXPECT_TRUE(rrc->GetHour() == 0) << "hour should be 0"; 52 53 auto rrcB = std::make_shared<ReminderRequestAlarm>(23, 1, daysOfWeek); 54 EXPECT_TRUE(rrcB->GetHour() == 23) << "hour should be 23"; 55 56 auto rrcC = std::make_shared<ReminderRequestAlarm>(1, 1, daysOfWeek); 57 EXPECT_TRUE(rrcC->GetHour() == 1) << "hour should be 1"; 58 59 auto rrcD = std::make_shared<ReminderRequestAlarm>(22, 1, daysOfWeek); 60 EXPECT_TRUE(rrcD->GetHour() == 22) << "hour should be 22"; 61 62 auto rrcE = std::make_shared<ReminderRequestAlarm>(12, 1, daysOfWeek); 63 EXPECT_TRUE(rrcE->GetHour() == 12) << "hour should be 12"; 64 } 65 66 /** 67 * @tc.name: initHour_00200 68 * @tc.desc: test set edge value of minute (0 and 59). 69 * @tc.type: FUNC 70 * @tc.require: SR000GGTRC AR000GH8E8 71 */ 72 HWTEST_F(ReminderRequestAlarmTest, initHour_00200, Function | SmallTest | Level1) 73 { 74 std::vector<uint8_t> daysOfWeek; 75 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 76 EXPECT_TRUE(rrc->GetMinute() == 0) << "minute should be 0"; 77 78 auto rrcB = std::make_shared<ReminderRequestAlarm>(23, 59, daysOfWeek); 79 EXPECT_TRUE(rrcB->GetMinute() == 59) << "minute should be 59"; 80 } 81 82 /** 83 * @tc.name: initDaysOfWeek_00100 84 * @tc.desc: test set daysOfWeek with normal value. 85 * @tc.type: FUNC 86 * @tc.require: SR000GGTRC AR000GH8E8 87 */ 88 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00100, Function | SmallTest | Level1) 89 { 90 uint8_t arr[] = {1, 2, 3}; 91 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 92 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 93 uint8_t expectedVal = 7; 94 EXPECT_TRUE(rrc->GetRepeatDay() == expectedVal) << "repeatDays (1, 2, 3) should be 7"; 95 } 96 97 /** 98 * @tc.name: initDaysOfWeek_00200 99 * @tc.desc: test set daysOfWeek with edge value. 100 * @tc.type: FUNC 101 * @tc.require: SR000GGTRC AR000GH8E8 102 */ 103 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00200, Function | SmallTest | Level1) 104 { 105 uint8_t arr[] = {1, 7}; 106 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 107 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 108 EXPECT_TRUE(rrc->GetRepeatDay() == 65) << "repeatDays (1, 12) should be 65"; 109 } 110 111 /** 112 * @tc.name: initDaysOfWeek_00300 113 * @tc.desc: test set daysOfWeek with duplicate value. 114 * @tc.type: FUNC 115 * @tc.require: SR000GGTRC AR000GH8E8 116 */ 117 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00300, Function | SmallTest | Level1) 118 { 119 uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7}; 120 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 121 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 122 EXPECT_TRUE(rrc->GetRepeatDay() == 81) << "repeatDays (1, 1, 5 12) should be 81"; 123 } 124 125 /** 126 * @tc.name: initDaysOfWeek_00400 127 * @tc.desc: test set daysOfWeek with null value. 128 * @tc.type: FUNC 129 * @tc.require: SR000GGTRC AR000GH8E8 130 */ 131 HWTEST_F(ReminderRequestAlarmTest, initDaysOfWeek_00400, Function | SmallTest | Level1) 132 { 133 uint8_t arr[] = {}; 134 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 135 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 136 uint8_t expectedVal = 0; 137 EXPECT_TRUE(rrc->GetRepeatDay() == expectedVal) << "repeatDays () should be 0"; 138 } 139 140 /** 141 * @tc.name: IsRepeatReminder_00100 142 * @tc.desc: Test IsRepeatReminder parameters. 143 * @tc.type: FUNC 144 * @tc.require: issue 145 */ 146 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00100, Function | SmallTest | Level1) 147 { 148 uint8_t arr[] = {}; 149 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 150 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 151 EXPECT_EQ(rrc->IsRepeatReminder(), false); 152 EXPECT_EQ(rrc->UpdateNextReminder(), false); 153 } 154 155 /** 156 * @tc.name: IsRepeatReminder_00200 157 * @tc.desc: Test IsRepeatReminder parameters. 158 * @tc.type: FUNC 159 * @tc.require: issue 160 */ 161 HWTEST_F(ReminderRequestAlarmTest, IsRepeatReminder_00200, Function | SmallTest | Level1) 162 { 163 uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7}; 164 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 165 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek); 166 EXPECT_EQ(rrc->IsRepeatReminder(), true); 167 EXPECT_EQ(rrc->UpdateNextReminder(), true); 168 } 169 170 /** 171 * @tc.name: PreGetNextTriggerTimeIgnoreSnooze_00100 172 * @tc.desc: Test PreGetNextTriggerTimeIgnoreSnooze parameters. 173 * @tc.type: FUNC 174 * @tc.require: issue 175 */ 176 HWTEST_F(ReminderRequestAlarmTest, PreGetNextTriggerTimeIgnoreSnooze_00100, Function | SmallTest | Level1) 177 { 178 bool ignoreRepeat = true; 179 bool forceToGetNext = true; 180 uint8_t arr[] = {1, 1, 5, 5, 7, 7, 7}; 181 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 182 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 1, daysOfWeek); 183 rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext); 184 EXPECT_EQ(rrc->GetNextTriggerTime(forceToGetNext), 185 rrc->PreGetNextTriggerTimeIgnoreSnooze(ignoreRepeat, forceToGetNext)); 186 } 187 188 /** 189 * @tc.name: GetDaysOfWeek_00100 190 * @tc.desc: Test GetDaysOfWeek parameters. 191 * @tc.type: FUNC 192 * @tc.require: issue 193 */ 194 HWTEST_F(ReminderRequestAlarmTest, GetDaysOfWeek_00100, Function | SmallTest | Level1) 195 { 196 uint8_t arr[] = {}; 197 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 198 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 199 auto ret = rrc->GetDaysOfWeek(); 200 EXPECT_EQ(ret.size(), 0); 201 } 202 203 /** 204 * @tc.name: OnDateTimeChange_00100 205 * @tc.desc: Test OnDateTimeChange parameters. 206 * @tc.type: FUNC 207 * @tc.require: issue 208 */ 209 HWTEST_F(ReminderRequestAlarmTest, OnDateTimeChange_00100, Function | SmallTest | Level1) 210 { 211 uint8_t arr[] = {}; 212 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 213 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 214 EXPECT_EQ(rrc->OnDateTimeChange(), false); 215 } 216 217 /** 218 * @tc.name: RecoverFromDb_00100 219 * @tc.desc: Test RecoverFromDb parameters. 220 * @tc.type: FUNC 221 * @tc.require: issue 222 */ 223 HWTEST_F(ReminderRequestAlarmTest, RecoverFromDb_00100, Function | SmallTest | Level1) 224 { 225 uint8_t arr[] = {}; 226 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 227 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 228 std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet = nullptr; 229 rrc->RecoverFromDb(resultSet); 230 uint8_t ret = rrc->GetRepeatDay(); 231 EXPECT_EQ(ret, 0); 232 } 233 234 /** 235 * @tc.name: Marshalling_00001 236 * @tc.desc: Test Marshalling parameters. 237 * @tc.type: FUNC 238 * @tc.require: issue 239 */ 240 HWTEST_F(ReminderRequestAlarmTest, Marshalling_00001, Function | SmallTest | Level1) 241 { 242 Parcel parcel; 243 uint8_t arr[] = {}; 244 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 245 auto rrc = std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 246 EXPECT_EQ(rrc->Marshalling(parcel), true); 247 } 248 249 /** 250 * @tc.name: Unmarshalling_00001 251 * @tc.desc: Test Unmarshalling parameters. 252 * @tc.type: FUNC 253 * @tc.require: issue 254 */ 255 HWTEST_F(ReminderRequestAlarmTest, Unmarshalling_001, Function | SmallTest | Level1) 256 { 257 bool unmarshalling = true; 258 Parcel parcel; 259 uint8_t arr[] = {}; 260 std::vector<uint8_t> daysOfWeek (arr, arr + sizeof(arr) / sizeof(uint8_t)); 261 std::shared_ptr<ReminderRequestAlarm> result = 262 std::make_shared<ReminderRequestAlarm>(0, 0, daysOfWeek); 263 if (nullptr != result) { 264 if (nullptr == result->Unmarshalling(parcel)) { 265 unmarshalling = false; 266 } 267 } 268 EXPECT_EQ(unmarshalling, false); 269 } 270 271 /** 272 * @tc.name: ReadFromParcel_00001 273 * @tc.desc: Test ReadFromParcel parameters. 274 * @tc.type: FUNC 275 * @tc.require: issueI 276 */ 277 HWTEST_F(ReminderRequestAlarmTest, ReadFromParcel_00001, Function | SmallTest | Level1) 278 { 279 Parcel parcel; 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 EXPECT_EQ(rrc->ReadFromParcel(parcel), false); 284 } 285 } 286 }