1 /* 2 * Copyright (c) 2024 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 #include <gmock/gmock.h> 18 #include <memory> 19 #include "native_calendar.h" 20 #include "native_calendar_manager.h" 21 #include "native_util.h" 22 23 24 namespace OHOS::CalendarApi::Native { 25 const std::string TEST_NAME = "EventRecurrenceRuleTest"; 26 static CalendarAccount account { 27 TEST_NAME, 28 "local", 29 "displayName_EventRecurrenceRuleTest" 30 }; 31 class EventRecurrenceRuleTest : public testing::Test { 32 public: SetUpTestSuite(void)33 static void SetUpTestSuite(void) 34 { 35 calendar = CalendarManager::GetInstance().CreateCalendar(account); 36 ASSERT_TRUE(calendar != nullptr); 37 } 38 TearDownTestSuite(void)39 static void TearDownTestSuite(void) 40 { 41 auto ret = CalendarManager::GetInstance().DeleteCalendar(*calendar.get()); 42 ASSERT_TRUE(ret); 43 } SetUp()44 void SetUp() {}; TearDown()45 void TearDown() {}; 46 static std::shared_ptr<Calendar> calendar; 47 }; 48 49 std::shared_ptr<Calendar> EventRecurrenceRuleTest::calendar = nullptr; 50 51 52 HWTEST_F(EventRecurrenceRuleTest, GetUTCTime, testing::ext::TestSize.Level1) 53 { 54 const int64_t timeValue = 1713672150000; 55 const std::string timeStr = "20240421T040230Z"; 56 57 const auto timeUTCStr = GetUTCTime(timeValue); 58 59 EXPECT_EQ(timeStr, timeUTCStr); 60 } 61 62 HWTEST_F(EventRecurrenceRuleTest, GetUTCTimes, testing::ext::TestSize.Level1) 63 { 64 std::vector<int64_t> excludedDates; 65 const int64_t timeValue = 1713672150000; 66 const std::string timeStr = "20240421T040230Z"; 67 68 excludedDates.emplace_back(timeValue); 69 const auto timeUTCStr = GetUTCTimes(excludedDates); 70 EXPECT_EQ(timeStr, timeUTCStr); 71 72 const int64_t timeVal = 1718942550000; 73 excludedDates.emplace_back(timeVal); 74 const std::string timeString = "20240421T040230Z,20240621T040230Z"; 75 76 const auto timeUTCString = GetUTCTimes(excludedDates); 77 EXPECT_EQ(timeString, timeUTCString); 78 } 79 80 HWTEST_F(EventRecurrenceRuleTest, TimeToUTC, testing::ext::TestSize.Level1) 81 { 82 const int64_t timeValue = 1713643350000; 83 const std::string timeStr = "20240421T040230Z"; 84 85 const int64_t timeUTCValue = TimeToUTC(timeStr); 86 87 EXPECT_EQ(timeValue, timeUTCValue); 88 } 89 90 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithDay, testing::ext::TestSize.Level1) 91 { 92 const int64_t timeValue = 1713672150000; 93 Event event; 94 event.startTime = 1713664950000; 95 RecurrenceRule recurrenceRule; 96 recurrenceRule.recurrenceFrequency = DAILY; 97 recurrenceRule.expire = std::make_optional<int64_t>(timeValue); 98 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 99 std::string rrule = "FREQ=DAILY;UNTIL=20240421T040230Z;WKST=SU"; 100 101 const auto value = GetRule(event); 102 103 EXPECT_EQ(value, rrule); 104 } 105 106 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithWeekly, testing::ext::TestSize.Level1) 107 { 108 Event event; 109 event.startTime = 1713664950000; 110 RecurrenceRule recurrenceRule; 111 recurrenceRule.recurrenceFrequency = WEEKLY; 112 recurrenceRule.interval = std::make_optional<int64_t>(2); 113 recurrenceRule.count = std::make_optional<int64_t>(3); 114 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 115 std::string rrule = "FREQ=WEEKLY;COUNT=3;INTERVAL=2;WKST=SU;BYDAY=SU"; 116 117 const auto value = GetRule(event); 118 119 EXPECT_EQ(value, rrule); 120 } 121 122 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithMonthly, testing::ext::TestSize.Level1) 123 { 124 const int64_t timeValue = 1713672150000; 125 Event event; 126 event.startTime = 1713664950000; 127 RecurrenceRule recurrenceRule; 128 recurrenceRule.recurrenceFrequency = MONTHLY; 129 recurrenceRule.expire = std::make_optional<int64_t>(timeValue); 130 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 131 std::string rrule = "FREQ=MONTHLY;UNTIL=20240421T040230Z;WKST=SU;BYMONTHDAY=21"; 132 133 const auto value = GetRule(event); 134 135 EXPECT_EQ(value, rrule); 136 } 137 138 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithYearly, testing::ext::TestSize.Level1) 139 { 140 const int64_t timeValue = 1713672150000; 141 Event event; 142 event.startTime = 1713664950000; 143 RecurrenceRule recurrenceRule; 144 recurrenceRule.recurrenceFrequency = YEARLY; 145 recurrenceRule.expire = std::make_optional<int64_t>(timeValue); 146 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 147 std::string rrule = "FREQ=YEARLY;UNTIL=20240421T040230Z;WKST=SU;BYMONTHDAY=21;BYMONTH=4"; 148 149 const auto value = GetRule(event); 150 151 EXPECT_EQ(value, rrule); 152 } 153 154 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithWeeklyList, testing::ext::TestSize.Level1) 155 { 156 Event event; 157 RecurrenceRule recurrenceRule; 158 recurrenceRule.recurrenceFrequency = WEEKLY; 159 recurrenceRule.daysOfWeek = {1, 2, 3, 4, 5, 6, 7}; 160 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 161 std::string rrule = "FREQ=WEEKLY;WKST=SU;BYDAY=MO,TU,WE,TH,FR,SA,SU"; 162 const auto value = GetRule(event); 163 164 EXPECT_EQ(value, rrule); 165 } 166 167 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithWeeksOfMonthlyList, testing::ext::TestSize.Level1) 168 { 169 Event event; 170 RecurrenceRule recurrenceRule; 171 recurrenceRule.recurrenceFrequency = MONTHLY; 172 recurrenceRule.weeksOfMonth = {2, 3}; 173 recurrenceRule.daysOfWeek = {3, 5}; 174 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 175 std::string rrule = "FREQ=MONTHLY;WKST=SU;BYDAY=2WE,3FR"; 176 const auto value = GetRule(event); 177 178 EXPECT_EQ(value, rrule); 179 } 180 181 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithDaysOfMonthlyList, testing::ext::TestSize.Level1) 182 { 183 Event event; 184 RecurrenceRule recurrenceRule; 185 recurrenceRule.recurrenceFrequency = MONTHLY; 186 recurrenceRule.daysOfMonth = {18, 19}; 187 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 188 std::string rrule = "FREQ=MONTHLY;WKST=SU;BYMONTHDAY=18,19"; 189 const auto value = GetRule(event); 190 191 EXPECT_EQ(value, rrule); 192 } 193 194 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithMonthsOfYearlyList, testing::ext::TestSize.Level1) 195 { 196 Event event; 197 RecurrenceRule recurrenceRule; 198 recurrenceRule.recurrenceFrequency = YEARLY; 199 recurrenceRule.monthsOfYear = {5, 6}; 200 recurrenceRule.daysOfMonth = {20, 21}; 201 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 202 std::string rrule = "FREQ=YEARLY;WKST=SU;BYMONTHDAY=20,21;BYMONTH=5,6"; 203 const auto value = GetRule(event); 204 205 EXPECT_EQ(value, rrule); 206 } 207 208 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithDaysOfYearlyList, testing::ext::TestSize.Level1) 209 { 210 Event event; 211 RecurrenceRule recurrenceRule; 212 recurrenceRule.recurrenceFrequency = YEARLY; 213 recurrenceRule.daysOfYear = {180, 360, 365}; 214 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 215 std::string rrule = "FREQ=YEARLY;WKST=SU;BYYEARDAY=180,360,365"; 216 const auto value = GetRule(event); 217 218 EXPECT_EQ(value, rrule); 219 } 220 221 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithWeeksOfYearlyList, testing::ext::TestSize.Level1) 222 { 223 Event event; 224 RecurrenceRule recurrenceRule; 225 recurrenceRule.recurrenceFrequency = YEARLY; 226 recurrenceRule.weeksOfYear = {5, 6, 7}; 227 recurrenceRule.daysOfWeek = {5, 6, 7}; 228 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 229 std::string rrule = "FREQ=YEARLY;WKST=SU;BYWEEKNO=5,6,7;BYDAY=FR,SA,SU"; 230 const auto value = GetRule(event); 231 232 EXPECT_EQ(value, rrule); 233 } 234 235 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithYearlyList, testing::ext::TestSize.Level1) 236 { 237 Event event; 238 RecurrenceRule recurrenceRule; 239 recurrenceRule.recurrenceFrequency = YEARLY; 240 recurrenceRule.interval = 2; 241 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 242 std::string rrule = "FREQ=YEARLY;INTERVAL=2;WKST=SU;BYMONTHDAY=1;BYMONTH=1"; 243 const auto value = GetRule(event); 244 245 EXPECT_EQ(value, rrule); 246 } 247 248 HWTEST_F(EventRecurrenceRuleTest, GetRuleWithDayOfWeekMonthYearlyList, testing::ext::TestSize.Level1) 249 { 250 Event event; 251 RecurrenceRule recurrenceRule; 252 recurrenceRule.recurrenceFrequency = YEARLY; 253 recurrenceRule.daysOfWeek = {1, 3, 5}; 254 recurrenceRule.weeksOfMonth = {2, 3, 4}; 255 recurrenceRule.monthsOfYear = {6, 7, 8}; 256 event.recurrenceRule = std::make_optional<RecurrenceRule>(recurrenceRule); 257 std::string rrule = "FREQ=YEARLY;WKST=SU;BYDAY=2MO,3WE,4FR;BYMONTH=6,7,8"; 258 const auto value = GetRule(event); 259 260 EXPECT_EQ(value, rrule); 261 } 262 263 }