civil_time_test.cc (54189B)
1 // Copyright 2018 The Abseil Authors. 2 // 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 // https://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 #include "absl/time/civil_time.h" 16 17 #include <iomanip> 18 #include <limits> 19 #include <sstream> 20 #include <type_traits> 21 22 #include "gtest/gtest.h" 23 #include "absl/base/macros.h" 24 #include "absl/hash/hash_testing.h" 25 #include "absl/strings/str_format.h" 26 27 namespace { 28 29 TEST(CivilTime, DefaultConstruction) { 30 absl::CivilSecond ss; 31 EXPECT_EQ("1970-01-01T00:00:00", absl::FormatCivilTime(ss)); 32 33 absl::CivilMinute mm; 34 EXPECT_EQ("1970-01-01T00:00", absl::FormatCivilTime(mm)); 35 36 absl::CivilHour hh; 37 EXPECT_EQ("1970-01-01T00", absl::FormatCivilTime(hh)); 38 39 absl::CivilDay d; 40 EXPECT_EQ("1970-01-01", absl::FormatCivilTime(d)); 41 42 absl::CivilMonth m; 43 EXPECT_EQ("1970-01", absl::FormatCivilTime(m)); 44 45 absl::CivilYear y; 46 EXPECT_EQ("1970", absl::FormatCivilTime(y)); 47 } 48 49 TEST(CivilTime, StructMember) { 50 struct S { 51 absl::CivilDay day; 52 }; 53 S s = {}; 54 EXPECT_EQ(absl::CivilDay{}, s.day); 55 } 56 57 TEST(CivilTime, FieldsConstruction) { 58 EXPECT_EQ("2015-01-02T03:04:05", 59 absl::FormatCivilTime(absl::CivilSecond(2015, 1, 2, 3, 4, 5))); 60 EXPECT_EQ("2015-01-02T03:04:00", 61 absl::FormatCivilTime(absl::CivilSecond(2015, 1, 2, 3, 4))); 62 EXPECT_EQ("2015-01-02T03:00:00", 63 absl::FormatCivilTime(absl::CivilSecond(2015, 1, 2, 3))); 64 EXPECT_EQ("2015-01-02T00:00:00", 65 absl::FormatCivilTime(absl::CivilSecond(2015, 1, 2))); 66 EXPECT_EQ("2015-01-01T00:00:00", 67 absl::FormatCivilTime(absl::CivilSecond(2015, 1))); 68 EXPECT_EQ("2015-01-01T00:00:00", 69 absl::FormatCivilTime(absl::CivilSecond(2015))); 70 71 EXPECT_EQ("2015-01-02T03:04", 72 absl::FormatCivilTime(absl::CivilMinute(2015, 1, 2, 3, 4, 5))); 73 EXPECT_EQ("2015-01-02T03:04", 74 absl::FormatCivilTime(absl::CivilMinute(2015, 1, 2, 3, 4))); 75 EXPECT_EQ("2015-01-02T03:00", 76 absl::FormatCivilTime(absl::CivilMinute(2015, 1, 2, 3))); 77 EXPECT_EQ("2015-01-02T00:00", 78 absl::FormatCivilTime(absl::CivilMinute(2015, 1, 2))); 79 EXPECT_EQ("2015-01-01T00:00", 80 absl::FormatCivilTime(absl::CivilMinute(2015, 1))); 81 EXPECT_EQ("2015-01-01T00:00", 82 absl::FormatCivilTime(absl::CivilMinute(2015))); 83 84 EXPECT_EQ("2015-01-02T03", 85 absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3, 4, 5))); 86 EXPECT_EQ("2015-01-02T03", 87 absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3, 4))); 88 EXPECT_EQ("2015-01-02T03", 89 absl::FormatCivilTime(absl::CivilHour(2015, 1, 2, 3))); 90 EXPECT_EQ("2015-01-02T00", 91 absl::FormatCivilTime(absl::CivilHour(2015, 1, 2))); 92 EXPECT_EQ("2015-01-01T00", 93 absl::FormatCivilTime(absl::CivilHour(2015, 1))); 94 EXPECT_EQ("2015-01-01T00", 95 absl::FormatCivilTime(absl::CivilHour(2015))); 96 97 EXPECT_EQ("2015-01-02", 98 absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3, 4, 5))); 99 EXPECT_EQ("2015-01-02", 100 absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3, 4))); 101 EXPECT_EQ("2015-01-02", 102 absl::FormatCivilTime(absl::CivilDay(2015, 1, 2, 3))); 103 EXPECT_EQ("2015-01-02", 104 absl::FormatCivilTime(absl::CivilDay(2015, 1, 2))); 105 EXPECT_EQ("2015-01-01", 106 absl::FormatCivilTime(absl::CivilDay(2015, 1))); 107 EXPECT_EQ("2015-01-01", 108 absl::FormatCivilTime(absl::CivilDay(2015))); 109 110 EXPECT_EQ("2015-01", 111 absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3, 4, 5))); 112 EXPECT_EQ("2015-01", 113 absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3, 4))); 114 EXPECT_EQ("2015-01", 115 absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2, 3))); 116 EXPECT_EQ("2015-01", 117 absl::FormatCivilTime(absl::CivilMonth(2015, 1, 2))); 118 EXPECT_EQ("2015-01", 119 absl::FormatCivilTime(absl::CivilMonth(2015, 1))); 120 EXPECT_EQ("2015-01", 121 absl::FormatCivilTime(absl::CivilMonth(2015))); 122 123 EXPECT_EQ("2015", 124 absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4, 5))); 125 EXPECT_EQ("2015", 126 absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3, 4))); 127 EXPECT_EQ("2015", 128 absl::FormatCivilTime(absl::CivilYear(2015, 1, 2, 3))); 129 EXPECT_EQ("2015", 130 absl::FormatCivilTime(absl::CivilYear(2015, 1, 2))); 131 EXPECT_EQ("2015", 132 absl::FormatCivilTime(absl::CivilYear(2015, 1))); 133 EXPECT_EQ("2015", 134 absl::FormatCivilTime(absl::CivilYear(2015))); 135 } 136 137 TEST(CivilTime, FieldsConstructionLimits) { 138 const int kIntMax = std::numeric_limits<int>::max(); 139 EXPECT_EQ("2038-01-19T03:14:07", 140 absl::FormatCivilTime(absl::CivilSecond( 141 1970, 1, 1, 0, 0, kIntMax))); 142 EXPECT_EQ("6121-02-11T05:21:07", 143 absl::FormatCivilTime(absl::CivilSecond( 144 1970, 1, 1, 0, kIntMax, kIntMax))); 145 EXPECT_EQ("251104-11-20T12:21:07", 146 absl::FormatCivilTime(absl::CivilSecond( 147 1970, 1, 1, kIntMax, kIntMax, kIntMax))); 148 EXPECT_EQ("6130715-05-30T12:21:07", 149 absl::FormatCivilTime(absl::CivilSecond( 150 1970, 1, kIntMax, kIntMax, kIntMax, kIntMax))); 151 EXPECT_EQ("185087685-11-26T12:21:07", 152 absl::FormatCivilTime(absl::CivilSecond( 153 1970, kIntMax, kIntMax, kIntMax, kIntMax, kIntMax))); 154 155 const int kIntMin = std::numeric_limits<int>::min(); 156 EXPECT_EQ("1901-12-13T20:45:52", 157 absl::FormatCivilTime(absl::CivilSecond( 158 1970, 1, 1, 0, 0, kIntMin))); 159 EXPECT_EQ("-2182-11-20T18:37:52", 160 absl::FormatCivilTime(absl::CivilSecond( 161 1970, 1, 1, 0, kIntMin, kIntMin))); 162 EXPECT_EQ("-247165-02-11T10:37:52", 163 absl::FormatCivilTime(absl::CivilSecond( 164 1970, 1, 1, kIntMin, kIntMin, kIntMin))); 165 EXPECT_EQ("-6126776-08-01T10:37:52", 166 absl::FormatCivilTime(absl::CivilSecond( 167 1970, 1, kIntMin, kIntMin, kIntMin, kIntMin))); 168 EXPECT_EQ("-185083747-10-31T10:37:52", 169 absl::FormatCivilTime(absl::CivilSecond( 170 1970, kIntMin, kIntMin, kIntMin, kIntMin, kIntMin))); 171 } 172 173 TEST(CivilTime, RangeLimits) { 174 const absl::civil_year_t kYearMax = 175 std::numeric_limits<absl::civil_year_t>::max(); 176 EXPECT_EQ(absl::CivilYear(kYearMax), 177 absl::CivilYear::max()); 178 EXPECT_EQ(absl::CivilMonth(kYearMax, 12), 179 absl::CivilMonth::max()); 180 EXPECT_EQ(absl::CivilDay(kYearMax, 12, 31), 181 absl::CivilDay::max()); 182 EXPECT_EQ(absl::CivilHour(kYearMax, 12, 31, 23), 183 absl::CivilHour::max()); 184 EXPECT_EQ(absl::CivilMinute(kYearMax, 12, 31, 23, 59), 185 absl::CivilMinute::max()); 186 EXPECT_EQ(absl::CivilSecond(kYearMax, 12, 31, 23, 59, 59), 187 absl::CivilSecond::max()); 188 189 const absl::civil_year_t kYearMin = 190 std::numeric_limits<absl::civil_year_t>::min(); 191 EXPECT_EQ(absl::CivilYear(kYearMin), 192 absl::CivilYear::min()); 193 EXPECT_EQ(absl::CivilMonth(kYearMin, 1), 194 absl::CivilMonth::min()); 195 EXPECT_EQ(absl::CivilDay(kYearMin, 1, 1), 196 absl::CivilDay::min()); 197 EXPECT_EQ(absl::CivilHour(kYearMin, 1, 1, 0), 198 absl::CivilHour::min()); 199 EXPECT_EQ(absl::CivilMinute(kYearMin, 1, 1, 0, 0), 200 absl::CivilMinute::min()); 201 EXPECT_EQ(absl::CivilSecond(kYearMin, 1, 1, 0, 0, 0), 202 absl::CivilSecond::min()); 203 } 204 205 TEST(CivilTime, ImplicitCrossAlignment) { 206 absl::CivilYear year(2015); 207 absl::CivilMonth month = year; 208 absl::CivilDay day = month; 209 absl::CivilHour hour = day; 210 absl::CivilMinute minute = hour; 211 absl::CivilSecond second = minute; 212 213 second = year; 214 EXPECT_EQ(second, year); 215 second = month; 216 EXPECT_EQ(second, month); 217 second = day; 218 EXPECT_EQ(second, day); 219 second = hour; 220 EXPECT_EQ(second, hour); 221 second = minute; 222 EXPECT_EQ(second, minute); 223 224 minute = year; 225 EXPECT_EQ(minute, year); 226 minute = month; 227 EXPECT_EQ(minute, month); 228 minute = day; 229 EXPECT_EQ(minute, day); 230 minute = hour; 231 EXPECT_EQ(minute, hour); 232 233 hour = year; 234 EXPECT_EQ(hour, year); 235 hour = month; 236 EXPECT_EQ(hour, month); 237 hour = day; 238 EXPECT_EQ(hour, day); 239 240 day = year; 241 EXPECT_EQ(day, year); 242 day = month; 243 EXPECT_EQ(day, month); 244 245 month = year; 246 EXPECT_EQ(month, year); 247 248 // Ensures unsafe conversions are not allowed. 249 EXPECT_FALSE( 250 (std::is_convertible<absl::CivilSecond, absl::CivilMinute>::value)); 251 EXPECT_FALSE( 252 (std::is_convertible<absl::CivilSecond, absl::CivilHour>::value)); 253 EXPECT_FALSE( 254 (std::is_convertible<absl::CivilSecond, absl::CivilDay>::value)); 255 EXPECT_FALSE( 256 (std::is_convertible<absl::CivilSecond, absl::CivilMonth>::value)); 257 EXPECT_FALSE( 258 (std::is_convertible<absl::CivilSecond, absl::CivilYear>::value)); 259 260 EXPECT_FALSE( 261 (std::is_convertible<absl::CivilMinute, absl::CivilHour>::value)); 262 EXPECT_FALSE( 263 (std::is_convertible<absl::CivilMinute, absl::CivilDay>::value)); 264 EXPECT_FALSE( 265 (std::is_convertible<absl::CivilMinute, absl::CivilMonth>::value)); 266 EXPECT_FALSE( 267 (std::is_convertible<absl::CivilMinute, absl::CivilYear>::value)); 268 269 EXPECT_FALSE( 270 (std::is_convertible<absl::CivilHour, absl::CivilDay>::value)); 271 EXPECT_FALSE( 272 (std::is_convertible<absl::CivilHour, absl::CivilMonth>::value)); 273 EXPECT_FALSE( 274 (std::is_convertible<absl::CivilHour, absl::CivilYear>::value)); 275 276 EXPECT_FALSE( 277 (std::is_convertible<absl::CivilDay, absl::CivilMonth>::value)); 278 EXPECT_FALSE( 279 (std::is_convertible<absl::CivilDay, absl::CivilYear>::value)); 280 281 EXPECT_FALSE( 282 (std::is_convertible<absl::CivilMonth, absl::CivilYear>::value)); 283 } 284 285 TEST(CivilTime, ExplicitCrossAlignment) { 286 // 287 // Assign from smaller units -> larger units 288 // 289 290 absl::CivilSecond second(2015, 1, 2, 3, 4, 5); 291 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(second)); 292 293 absl::CivilMinute minute(second); 294 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(minute)); 295 296 absl::CivilHour hour(minute); 297 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(hour)); 298 299 absl::CivilDay day(hour); 300 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(day)); 301 302 absl::CivilMonth month(day); 303 EXPECT_EQ("2015-01", absl::FormatCivilTime(month)); 304 305 absl::CivilYear year(month); 306 EXPECT_EQ("2015", absl::FormatCivilTime(year)); 307 308 // 309 // Now assign from larger units -> smaller units 310 // 311 312 month = absl::CivilMonth(year); 313 EXPECT_EQ("2015-01", absl::FormatCivilTime(month)); 314 315 day = absl::CivilDay(month); 316 EXPECT_EQ("2015-01-01", absl::FormatCivilTime(day)); 317 318 hour = absl::CivilHour(day); 319 EXPECT_EQ("2015-01-01T00", absl::FormatCivilTime(hour)); 320 321 minute = absl::CivilMinute(hour); 322 EXPECT_EQ("2015-01-01T00:00", absl::FormatCivilTime(minute)); 323 324 second = absl::CivilSecond(minute); 325 EXPECT_EQ("2015-01-01T00:00:00", absl::FormatCivilTime(second)); 326 } 327 328 // Metafunction to test whether difference is allowed between two types. 329 template <typename T1, typename T2> 330 struct HasDiff { 331 template <typename U1, typename U2> 332 static std::false_type test(...); 333 template <typename U1, typename U2> 334 static std::true_type test(decltype(std::declval<U1>() - std::declval<U2>())); 335 static constexpr bool value = decltype(test<T1, T2>(0))::value; 336 }; 337 338 TEST(CivilTime, DisallowCrossAlignedDifference) { 339 // Difference is allowed between types with the same alignment. 340 static_assert(HasDiff<absl::CivilSecond, absl::CivilSecond>::value, ""); 341 static_assert(HasDiff<absl::CivilMinute, absl::CivilMinute>::value, ""); 342 static_assert(HasDiff<absl::CivilHour, absl::CivilHour>::value, ""); 343 static_assert(HasDiff<absl::CivilDay, absl::CivilDay>::value, ""); 344 static_assert(HasDiff<absl::CivilMonth, absl::CivilMonth>::value, ""); 345 static_assert(HasDiff<absl::CivilYear, absl::CivilYear>::value, ""); 346 347 // Difference is disallowed between types with different alignments. 348 static_assert(!HasDiff<absl::CivilSecond, absl::CivilMinute>::value, ""); 349 static_assert(!HasDiff<absl::CivilSecond, absl::CivilHour>::value, ""); 350 static_assert(!HasDiff<absl::CivilSecond, absl::CivilDay>::value, ""); 351 static_assert(!HasDiff<absl::CivilSecond, absl::CivilMonth>::value, ""); 352 static_assert(!HasDiff<absl::CivilSecond, absl::CivilYear>::value, ""); 353 354 static_assert(!HasDiff<absl::CivilMinute, absl::CivilHour>::value, ""); 355 static_assert(!HasDiff<absl::CivilMinute, absl::CivilDay>::value, ""); 356 static_assert(!HasDiff<absl::CivilMinute, absl::CivilMonth>::value, ""); 357 static_assert(!HasDiff<absl::CivilMinute, absl::CivilYear>::value, ""); 358 359 static_assert(!HasDiff<absl::CivilHour, absl::CivilDay>::value, ""); 360 static_assert(!HasDiff<absl::CivilHour, absl::CivilMonth>::value, ""); 361 static_assert(!HasDiff<absl::CivilHour, absl::CivilYear>::value, ""); 362 363 static_assert(!HasDiff<absl::CivilDay, absl::CivilMonth>::value, ""); 364 static_assert(!HasDiff<absl::CivilDay, absl::CivilYear>::value, ""); 365 366 static_assert(!HasDiff<absl::CivilMonth, absl::CivilYear>::value, ""); 367 } 368 369 TEST(CivilTime, ValueSemantics) { 370 const absl::CivilHour a(2015, 1, 2, 3); 371 const absl::CivilHour b = a; 372 const absl::CivilHour c(b); 373 absl::CivilHour d; 374 d = c; 375 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(d)); 376 } 377 378 TEST(CivilTime, Relational) { 379 // Tests that the alignment unit is ignored in comparison. 380 const absl::CivilYear year(2014); 381 const absl::CivilMonth month(year); 382 EXPECT_EQ(year, month); 383 384 #define TEST_RELATIONAL(OLDER, YOUNGER) \ 385 do { \ 386 EXPECT_FALSE(OLDER < OLDER); \ 387 EXPECT_FALSE(OLDER > OLDER); \ 388 EXPECT_TRUE(OLDER >= OLDER); \ 389 EXPECT_TRUE(OLDER <= OLDER); \ 390 EXPECT_FALSE(YOUNGER < YOUNGER); \ 391 EXPECT_FALSE(YOUNGER > YOUNGER); \ 392 EXPECT_TRUE(YOUNGER >= YOUNGER); \ 393 EXPECT_TRUE(YOUNGER <= YOUNGER); \ 394 EXPECT_EQ(OLDER, OLDER); \ 395 EXPECT_NE(OLDER, YOUNGER); \ 396 EXPECT_LT(OLDER, YOUNGER); \ 397 EXPECT_LE(OLDER, YOUNGER); \ 398 EXPECT_GT(YOUNGER, OLDER); \ 399 EXPECT_GE(YOUNGER, OLDER); \ 400 } while (0) 401 402 // Alignment is ignored in comparison (verified above), so CivilSecond is 403 // used to test comparison in all field positions. 404 TEST_RELATIONAL(absl::CivilSecond(2014, 1, 1, 0, 0, 0), 405 absl::CivilSecond(2015, 1, 1, 0, 0, 0)); 406 TEST_RELATIONAL(absl::CivilSecond(2014, 1, 1, 0, 0, 0), 407 absl::CivilSecond(2014, 2, 1, 0, 0, 0)); 408 TEST_RELATIONAL(absl::CivilSecond(2014, 1, 1, 0, 0, 0), 409 absl::CivilSecond(2014, 1, 2, 0, 0, 0)); 410 TEST_RELATIONAL(absl::CivilSecond(2014, 1, 1, 0, 0, 0), 411 absl::CivilSecond(2014, 1, 1, 1, 0, 0)); 412 TEST_RELATIONAL(absl::CivilSecond(2014, 1, 1, 1, 0, 0), 413 absl::CivilSecond(2014, 1, 1, 1, 1, 0)); 414 TEST_RELATIONAL(absl::CivilSecond(2014, 1, 1, 1, 1, 0), 415 absl::CivilSecond(2014, 1, 1, 1, 1, 1)); 416 417 // Tests the relational operators of two different civil-time types. 418 TEST_RELATIONAL(absl::CivilDay(2014, 1, 1), 419 absl::CivilMinute(2014, 1, 1, 1, 1)); 420 TEST_RELATIONAL(absl::CivilDay(2014, 1, 1), 421 absl::CivilMonth(2014, 2)); 422 423 #undef TEST_RELATIONAL 424 } 425 426 TEST(CivilTime, Arithmetic) { 427 absl::CivilSecond second(2015, 1, 2, 3, 4, 5); 428 EXPECT_EQ("2015-01-02T03:04:06", absl::FormatCivilTime(second += 1)); 429 EXPECT_EQ("2015-01-02T03:04:07", absl::FormatCivilTime(second + 1)); 430 EXPECT_EQ("2015-01-02T03:04:08", absl::FormatCivilTime(2 + second)); 431 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(second - 1)); 432 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(second -= 1)); 433 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(second++)); 434 EXPECT_EQ("2015-01-02T03:04:07", absl::FormatCivilTime(++second)); 435 EXPECT_EQ("2015-01-02T03:04:07", absl::FormatCivilTime(second--)); 436 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(--second)); 437 438 absl::CivilMinute minute(2015, 1, 2, 3, 4); 439 EXPECT_EQ("2015-01-02T03:05", absl::FormatCivilTime(minute += 1)); 440 EXPECT_EQ("2015-01-02T03:06", absl::FormatCivilTime(minute + 1)); 441 EXPECT_EQ("2015-01-02T03:07", absl::FormatCivilTime(2 + minute)); 442 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(minute - 1)); 443 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(minute -= 1)); 444 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(minute++)); 445 EXPECT_EQ("2015-01-02T03:06", absl::FormatCivilTime(++minute)); 446 EXPECT_EQ("2015-01-02T03:06", absl::FormatCivilTime(minute--)); 447 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(--minute)); 448 449 absl::CivilHour hour(2015, 1, 2, 3); 450 EXPECT_EQ("2015-01-02T04", absl::FormatCivilTime(hour += 1)); 451 EXPECT_EQ("2015-01-02T05", absl::FormatCivilTime(hour + 1)); 452 EXPECT_EQ("2015-01-02T06", absl::FormatCivilTime(2 + hour)); 453 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(hour - 1)); 454 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(hour -= 1)); 455 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(hour++)); 456 EXPECT_EQ("2015-01-02T05", absl::FormatCivilTime(++hour)); 457 EXPECT_EQ("2015-01-02T05", absl::FormatCivilTime(hour--)); 458 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(--hour)); 459 460 absl::CivilDay day(2015, 1, 2); 461 EXPECT_EQ("2015-01-03", absl::FormatCivilTime(day += 1)); 462 EXPECT_EQ("2015-01-04", absl::FormatCivilTime(day + 1)); 463 EXPECT_EQ("2015-01-05", absl::FormatCivilTime(2 + day)); 464 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(day - 1)); 465 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(day -= 1)); 466 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(day++)); 467 EXPECT_EQ("2015-01-04", absl::FormatCivilTime(++day)); 468 EXPECT_EQ("2015-01-04", absl::FormatCivilTime(day--)); 469 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(--day)); 470 471 absl::CivilMonth month(2015, 1); 472 EXPECT_EQ("2015-02", absl::FormatCivilTime(month += 1)); 473 EXPECT_EQ("2015-03", absl::FormatCivilTime(month + 1)); 474 EXPECT_EQ("2015-04", absl::FormatCivilTime(2 + month)); 475 EXPECT_EQ("2015-01", absl::FormatCivilTime(month - 1)); 476 EXPECT_EQ("2015-01", absl::FormatCivilTime(month -= 1)); 477 EXPECT_EQ("2015-01", absl::FormatCivilTime(month++)); 478 EXPECT_EQ("2015-03", absl::FormatCivilTime(++month)); 479 EXPECT_EQ("2015-03", absl::FormatCivilTime(month--)); 480 EXPECT_EQ("2015-01", absl::FormatCivilTime(--month)); 481 482 absl::CivilYear year(2015); 483 EXPECT_EQ("2016", absl::FormatCivilTime(year += 1)); 484 EXPECT_EQ("2017", absl::FormatCivilTime(year + 1)); 485 EXPECT_EQ("2018", absl::FormatCivilTime(2 + year)); 486 EXPECT_EQ("2015", absl::FormatCivilTime(year - 1)); 487 EXPECT_EQ("2015", absl::FormatCivilTime(year -= 1)); 488 EXPECT_EQ("2015", absl::FormatCivilTime(year++)); 489 EXPECT_EQ("2017", absl::FormatCivilTime(++year)); 490 EXPECT_EQ("2017", absl::FormatCivilTime(year--)); 491 EXPECT_EQ("2015", absl::FormatCivilTime(--year)); 492 } 493 494 TEST(CivilTime, ArithmeticLimits) { 495 const int kIntMax = std::numeric_limits<int>::max(); 496 const int kIntMin = std::numeric_limits<int>::min(); 497 498 absl::CivilSecond second(1970, 1, 1, 0, 0, 0); 499 second += kIntMax; 500 EXPECT_EQ("2038-01-19T03:14:07", absl::FormatCivilTime(second)); 501 second -= kIntMax; 502 EXPECT_EQ("1970-01-01T00:00:00", absl::FormatCivilTime(second)); 503 second += kIntMin; 504 EXPECT_EQ("1901-12-13T20:45:52", absl::FormatCivilTime(second)); 505 second -= kIntMin; 506 EXPECT_EQ("1970-01-01T00:00:00", absl::FormatCivilTime(second)); 507 508 absl::CivilMinute minute(1970, 1, 1, 0, 0); 509 minute += kIntMax; 510 EXPECT_EQ("6053-01-23T02:07", absl::FormatCivilTime(minute)); 511 minute -= kIntMax; 512 EXPECT_EQ("1970-01-01T00:00", absl::FormatCivilTime(minute)); 513 minute += kIntMin; 514 EXPECT_EQ("-2114-12-08T21:52", absl::FormatCivilTime(minute)); 515 minute -= kIntMin; 516 EXPECT_EQ("1970-01-01T00:00", absl::FormatCivilTime(minute)); 517 518 absl::CivilHour hour(1970, 1, 1, 0); 519 hour += kIntMax; 520 EXPECT_EQ("246953-10-09T07", absl::FormatCivilTime(hour)); 521 hour -= kIntMax; 522 EXPECT_EQ("1970-01-01T00", absl::FormatCivilTime(hour)); 523 hour += kIntMin; 524 EXPECT_EQ("-243014-03-24T16", absl::FormatCivilTime(hour)); 525 hour -= kIntMin; 526 EXPECT_EQ("1970-01-01T00", absl::FormatCivilTime(hour)); 527 528 absl::CivilDay day(1970, 1, 1); 529 day += kIntMax; 530 EXPECT_EQ("5881580-07-11", absl::FormatCivilTime(day)); 531 day -= kIntMax; 532 EXPECT_EQ("1970-01-01", absl::FormatCivilTime(day)); 533 day += kIntMin; 534 EXPECT_EQ("-5877641-06-23", absl::FormatCivilTime(day)); 535 day -= kIntMin; 536 EXPECT_EQ("1970-01-01", absl::FormatCivilTime(day)); 537 538 absl::CivilMonth month(1970, 1); 539 month += kIntMax; 540 EXPECT_EQ("178958940-08", absl::FormatCivilTime(month)); 541 month -= kIntMax; 542 EXPECT_EQ("1970-01", absl::FormatCivilTime(month)); 543 month += kIntMin; 544 EXPECT_EQ("-178955001-05", absl::FormatCivilTime(month)); 545 month -= kIntMin; 546 EXPECT_EQ("1970-01", absl::FormatCivilTime(month)); 547 548 absl::CivilYear year(0); 549 year += kIntMax; 550 EXPECT_EQ("2147483647", absl::FormatCivilTime(year)); 551 year -= kIntMax; 552 EXPECT_EQ("0", absl::FormatCivilTime(year)); 553 year += kIntMin; 554 EXPECT_EQ("-2147483648", absl::FormatCivilTime(year)); 555 year -= kIntMin; 556 EXPECT_EQ("0", absl::FormatCivilTime(year)); 557 } 558 559 TEST(CivilTime, Difference) { 560 absl::CivilSecond second(2015, 1, 2, 3, 4, 5); 561 EXPECT_EQ(0, second - second); 562 EXPECT_EQ(10, (second + 10) - second); 563 EXPECT_EQ(-10, (second - 10) - second); 564 565 absl::CivilMinute minute(2015, 1, 2, 3, 4); 566 EXPECT_EQ(0, minute - minute); 567 EXPECT_EQ(10, (minute + 10) - minute); 568 EXPECT_EQ(-10, (minute - 10) - minute); 569 570 absl::CivilHour hour(2015, 1, 2, 3); 571 EXPECT_EQ(0, hour - hour); 572 EXPECT_EQ(10, (hour + 10) - hour); 573 EXPECT_EQ(-10, (hour - 10) - hour); 574 575 absl::CivilDay day(2015, 1, 2); 576 EXPECT_EQ(0, day - day); 577 EXPECT_EQ(10, (day + 10) - day); 578 EXPECT_EQ(-10, (day - 10) - day); 579 580 absl::CivilMonth month(2015, 1); 581 EXPECT_EQ(0, month - month); 582 EXPECT_EQ(10, (month + 10) - month); 583 EXPECT_EQ(-10, (month - 10) - month); 584 585 absl::CivilYear year(2015); 586 EXPECT_EQ(0, year - year); 587 EXPECT_EQ(10, (year + 10) - year); 588 EXPECT_EQ(-10, (year - 10) - year); 589 } 590 591 TEST(CivilTime, DifferenceLimits) { 592 const absl::civil_diff_t kDiffMax = 593 std::numeric_limits<absl::civil_diff_t>::max(); 594 const absl::civil_diff_t kDiffMin = 595 std::numeric_limits<absl::civil_diff_t>::min(); 596 597 // Check day arithmetic at the end of the year range. 598 const absl::CivilDay max_day(kDiffMax, 12, 31); 599 EXPECT_EQ(1, max_day - (max_day - 1)); 600 EXPECT_EQ(-1, (max_day - 1) - max_day); 601 602 // Check day arithmetic at the start of the year range. 603 const absl::CivilDay min_day(kDiffMin, 1, 1); 604 EXPECT_EQ(1, (min_day + 1) - min_day); 605 EXPECT_EQ(-1, min_day - (min_day + 1)); 606 607 // Check the limits of the return value. 608 const absl::CivilDay d1(1970, 1, 1); 609 const absl::CivilDay d2(25252734927768524, 7, 27); 610 EXPECT_EQ(kDiffMax, d2 - d1); 611 EXPECT_EQ(kDiffMin, d1 - (d2 + 1)); 612 } 613 614 TEST(CivilTime, Properties) { 615 absl::CivilSecond ss(2015, 2, 3, 4, 5, 6); 616 EXPECT_EQ(2015, ss.year()); 617 EXPECT_EQ(2, ss.month()); 618 EXPECT_EQ(3, ss.day()); 619 EXPECT_EQ(4, ss.hour()); 620 EXPECT_EQ(5, ss.minute()); 621 EXPECT_EQ(6, ss.second()); 622 EXPECT_EQ(absl::Weekday::tuesday, absl::GetWeekday(ss)); 623 EXPECT_EQ(34, absl::GetYearDay(ss)); 624 625 absl::CivilMinute mm(2015, 2, 3, 4, 5, 6); 626 EXPECT_EQ(2015, mm.year()); 627 EXPECT_EQ(2, mm.month()); 628 EXPECT_EQ(3, mm.day()); 629 EXPECT_EQ(4, mm.hour()); 630 EXPECT_EQ(5, mm.minute()); 631 EXPECT_EQ(0, mm.second()); 632 EXPECT_EQ(absl::Weekday::tuesday, absl::GetWeekday(mm)); 633 EXPECT_EQ(34, absl::GetYearDay(mm)); 634 635 absl::CivilHour hh(2015, 2, 3, 4, 5, 6); 636 EXPECT_EQ(2015, hh.year()); 637 EXPECT_EQ(2, hh.month()); 638 EXPECT_EQ(3, hh.day()); 639 EXPECT_EQ(4, hh.hour()); 640 EXPECT_EQ(0, hh.minute()); 641 EXPECT_EQ(0, hh.second()); 642 EXPECT_EQ(absl::Weekday::tuesday, absl::GetWeekday(hh)); 643 EXPECT_EQ(34, absl::GetYearDay(hh)); 644 645 absl::CivilDay d(2015, 2, 3, 4, 5, 6); 646 EXPECT_EQ(2015, d.year()); 647 EXPECT_EQ(2, d.month()); 648 EXPECT_EQ(3, d.day()); 649 EXPECT_EQ(0, d.hour()); 650 EXPECT_EQ(0, d.minute()); 651 EXPECT_EQ(0, d.second()); 652 EXPECT_EQ(absl::Weekday::tuesday, absl::GetWeekday(d)); 653 EXPECT_EQ(34, absl::GetYearDay(d)); 654 655 absl::CivilMonth m(2015, 2, 3, 4, 5, 6); 656 EXPECT_EQ(2015, m.year()); 657 EXPECT_EQ(2, m.month()); 658 EXPECT_EQ(1, m.day()); 659 EXPECT_EQ(0, m.hour()); 660 EXPECT_EQ(0, m.minute()); 661 EXPECT_EQ(0, m.second()); 662 EXPECT_EQ(absl::Weekday::sunday, absl::GetWeekday(m)); 663 EXPECT_EQ(32, absl::GetYearDay(m)); 664 665 absl::CivilYear y(2015, 2, 3, 4, 5, 6); 666 EXPECT_EQ(2015, y.year()); 667 EXPECT_EQ(1, y.month()); 668 EXPECT_EQ(1, y.day()); 669 EXPECT_EQ(0, y.hour()); 670 EXPECT_EQ(0, y.minute()); 671 EXPECT_EQ(0, y.second()); 672 EXPECT_EQ(absl::Weekday::thursday, absl::GetWeekday(y)); 673 EXPECT_EQ(1, absl::GetYearDay(y)); 674 } 675 676 TEST(CivilTime, Format) { 677 absl::CivilSecond ss; 678 EXPECT_EQ("1970-01-01T00:00:00", absl::FormatCivilTime(ss)); 679 680 absl::CivilMinute mm; 681 EXPECT_EQ("1970-01-01T00:00", absl::FormatCivilTime(mm)); 682 683 absl::CivilHour hh; 684 EXPECT_EQ("1970-01-01T00", absl::FormatCivilTime(hh)); 685 686 absl::CivilDay d; 687 EXPECT_EQ("1970-01-01", absl::FormatCivilTime(d)); 688 689 absl::CivilMonth m; 690 EXPECT_EQ("1970-01", absl::FormatCivilTime(m)); 691 692 absl::CivilYear y; 693 EXPECT_EQ("1970", absl::FormatCivilTime(y)); 694 } 695 696 TEST(CivilTime, Parse) { 697 absl::CivilSecond ss; 698 absl::CivilMinute mm; 699 absl::CivilHour hh; 700 absl::CivilDay d; 701 absl::CivilMonth m; 702 absl::CivilYear y; 703 704 // CivilSecond OK; others fail 705 EXPECT_TRUE(absl::ParseCivilTime("2015-01-02T03:04:05", &ss)); 706 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(ss)); 707 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04:05", &mm)); 708 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04:05", &hh)); 709 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04:05", &d)); 710 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04:05", &m)); 711 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04:05", &y)); 712 713 // CivilMinute OK; others fail 714 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04", &ss)); 715 EXPECT_TRUE(absl::ParseCivilTime("2015-01-02T03:04", &mm)); 716 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(mm)); 717 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04", &hh)); 718 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04", &d)); 719 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04", &m)); 720 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03:04", &y)); 721 722 // CivilHour OK; others fail 723 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03", &ss)); 724 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03", &mm)); 725 EXPECT_TRUE(absl::ParseCivilTime("2015-01-02T03", &hh)); 726 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(hh)); 727 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03", &d)); 728 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03", &m)); 729 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02T03", &y)); 730 731 // CivilDay OK; others fail 732 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02", &ss)); 733 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02", &mm)); 734 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02", &hh)); 735 EXPECT_TRUE(absl::ParseCivilTime("2015-01-02", &d)); 736 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(d)); 737 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02", &m)); 738 EXPECT_FALSE(absl::ParseCivilTime("2015-01-02", &y)); 739 740 // CivilMonth OK; others fail 741 EXPECT_FALSE(absl::ParseCivilTime("2015-01", &ss)); 742 EXPECT_FALSE(absl::ParseCivilTime("2015-01", &mm)); 743 EXPECT_FALSE(absl::ParseCivilTime("2015-01", &hh)); 744 EXPECT_FALSE(absl::ParseCivilTime("2015-01", &d)); 745 EXPECT_TRUE(absl::ParseCivilTime("2015-01", &m)); 746 EXPECT_EQ("2015-01", absl::FormatCivilTime(m)); 747 EXPECT_FALSE(absl::ParseCivilTime("2015-01", &y)); 748 749 // CivilYear OK; others fail 750 EXPECT_FALSE(absl::ParseCivilTime("2015", &ss)); 751 EXPECT_FALSE(absl::ParseCivilTime("2015", &mm)); 752 EXPECT_FALSE(absl::ParseCivilTime("2015", &hh)); 753 EXPECT_FALSE(absl::ParseCivilTime("2015", &d)); 754 EXPECT_FALSE(absl::ParseCivilTime("2015", &m)); 755 EXPECT_TRUE(absl::ParseCivilTime("2015", &y)); 756 EXPECT_EQ("2015", absl::FormatCivilTime(y)); 757 } 758 759 TEST(CivilTime, FormatAndParseLenient) { 760 absl::CivilSecond ss; 761 EXPECT_EQ("1970-01-01T00:00:00", absl::FormatCivilTime(ss)); 762 763 absl::CivilMinute mm; 764 EXPECT_EQ("1970-01-01T00:00", absl::FormatCivilTime(mm)); 765 766 absl::CivilHour hh; 767 EXPECT_EQ("1970-01-01T00", absl::FormatCivilTime(hh)); 768 769 absl::CivilDay d; 770 EXPECT_EQ("1970-01-01", absl::FormatCivilTime(d)); 771 772 absl::CivilMonth m; 773 EXPECT_EQ("1970-01", absl::FormatCivilTime(m)); 774 775 absl::CivilYear y; 776 EXPECT_EQ("1970", absl::FormatCivilTime(y)); 777 778 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-01-02T03:04:05", &ss)); 779 EXPECT_EQ("2015-01-02T03:04:05", absl::FormatCivilTime(ss)); 780 781 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-01-02T03:04:05", &mm)); 782 EXPECT_EQ("2015-01-02T03:04", absl::FormatCivilTime(mm)); 783 784 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-01-02T03:04:05", &hh)); 785 EXPECT_EQ("2015-01-02T03", absl::FormatCivilTime(hh)); 786 787 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-01-02T03:04:05", &d)); 788 EXPECT_EQ("2015-01-02", absl::FormatCivilTime(d)); 789 790 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-01-02T03:04:05", &m)); 791 EXPECT_EQ("2015-01", absl::FormatCivilTime(m)); 792 793 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-01-02T03:04:05", &y)); 794 EXPECT_EQ("2015", absl::FormatCivilTime(y)); 795 } 796 797 TEST(CivilTime, ParseEdgeCases) { 798 absl::CivilSecond ss; 799 EXPECT_TRUE( 800 absl::ParseLenientCivilTime("9223372036854775807-12-31T23:59:59", &ss)); 801 EXPECT_EQ("9223372036854775807-12-31T23:59:59", absl::FormatCivilTime(ss)); 802 EXPECT_TRUE( 803 absl::ParseLenientCivilTime("-9223372036854775808-01-01T00:00:00", &ss)); 804 EXPECT_EQ("-9223372036854775808-01-01T00:00:00", absl::FormatCivilTime(ss)); 805 806 absl::CivilMinute mm; 807 EXPECT_TRUE( 808 absl::ParseLenientCivilTime("9223372036854775807-12-31T23:59", &mm)); 809 EXPECT_EQ("9223372036854775807-12-31T23:59", absl::FormatCivilTime(mm)); 810 EXPECT_TRUE( 811 absl::ParseLenientCivilTime("-9223372036854775808-01-01T00:00", &mm)); 812 EXPECT_EQ("-9223372036854775808-01-01T00:00", absl::FormatCivilTime(mm)); 813 814 absl::CivilHour hh; 815 EXPECT_TRUE( 816 absl::ParseLenientCivilTime("9223372036854775807-12-31T23", &hh)); 817 EXPECT_EQ("9223372036854775807-12-31T23", absl::FormatCivilTime(hh)); 818 EXPECT_TRUE( 819 absl::ParseLenientCivilTime("-9223372036854775808-01-01T00", &hh)); 820 EXPECT_EQ("-9223372036854775808-01-01T00", absl::FormatCivilTime(hh)); 821 822 absl::CivilDay d; 823 EXPECT_TRUE(absl::ParseLenientCivilTime("9223372036854775807-12-31", &d)); 824 EXPECT_EQ("9223372036854775807-12-31", absl::FormatCivilTime(d)); 825 EXPECT_TRUE(absl::ParseLenientCivilTime("-9223372036854775808-01-01", &d)); 826 EXPECT_EQ("-9223372036854775808-01-01", absl::FormatCivilTime(d)); 827 828 absl::CivilMonth m; 829 EXPECT_TRUE(absl::ParseLenientCivilTime("9223372036854775807-12", &m)); 830 EXPECT_EQ("9223372036854775807-12", absl::FormatCivilTime(m)); 831 EXPECT_TRUE(absl::ParseLenientCivilTime("-9223372036854775808-01", &m)); 832 EXPECT_EQ("-9223372036854775808-01", absl::FormatCivilTime(m)); 833 834 absl::CivilYear y; 835 EXPECT_TRUE(absl::ParseLenientCivilTime("9223372036854775807", &y)); 836 EXPECT_EQ("9223372036854775807", absl::FormatCivilTime(y)); 837 EXPECT_TRUE(absl::ParseLenientCivilTime("-9223372036854775808", &y)); 838 EXPECT_EQ("-9223372036854775808", absl::FormatCivilTime(y)); 839 840 // Tests some valid, but interesting, cases 841 EXPECT_TRUE(absl::ParseLenientCivilTime("0", &ss)) << ss; 842 EXPECT_EQ(absl::CivilYear(0), ss); 843 EXPECT_TRUE(absl::ParseLenientCivilTime("0-1", &ss)) << ss; 844 EXPECT_EQ(absl::CivilMonth(0, 1), ss); 845 EXPECT_TRUE(absl::ParseLenientCivilTime(" 2015 ", &ss)) << ss; 846 EXPECT_EQ(absl::CivilYear(2015), ss); 847 EXPECT_TRUE(absl::ParseLenientCivilTime(" 2015-6 ", &ss)) << ss; 848 EXPECT_EQ(absl::CivilMonth(2015, 6), ss); 849 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-6-7", &ss)) << ss; 850 EXPECT_EQ(absl::CivilDay(2015, 6, 7), ss); 851 EXPECT_TRUE(absl::ParseLenientCivilTime(" 2015-6-7 ", &ss)) << ss; 852 EXPECT_EQ(absl::CivilDay(2015, 6, 7), ss); 853 EXPECT_TRUE(absl::ParseLenientCivilTime("2015-06-07T10:11:12 ", &ss)) << ss; 854 EXPECT_EQ(absl::CivilSecond(2015, 6, 7, 10, 11, 12), ss); 855 EXPECT_TRUE(absl::ParseLenientCivilTime(" 2015-06-07T10:11:12 ", &ss)) << ss; 856 EXPECT_EQ(absl::CivilSecond(2015, 6, 7, 10, 11, 12), ss); 857 EXPECT_TRUE(absl::ParseLenientCivilTime("-01-01", &ss)) << ss; 858 EXPECT_EQ(absl::CivilMonth(-1, 1), ss); 859 860 // Tests some invalid cases 861 EXPECT_FALSE(absl::ParseLenientCivilTime("01-01-2015", &ss)) << ss; 862 EXPECT_FALSE(absl::ParseLenientCivilTime("2015-", &ss)) << ss; 863 EXPECT_FALSE(absl::ParseLenientCivilTime("0xff-01", &ss)) << ss; 864 EXPECT_FALSE(absl::ParseLenientCivilTime("2015-02-30T04:05:06", &ss)) << ss; 865 EXPECT_FALSE(absl::ParseLenientCivilTime("2015-02-03T04:05:96", &ss)) << ss; 866 EXPECT_FALSE(absl::ParseLenientCivilTime("X2015-02-03T04:05:06", &ss)) << ss; 867 EXPECT_FALSE(absl::ParseLenientCivilTime("2015-02-03T04:05:003", &ss)) << ss; 868 EXPECT_FALSE(absl::ParseLenientCivilTime("2015 -02-03T04:05:06", &ss)) << ss; 869 EXPECT_FALSE(absl::ParseLenientCivilTime("2015-02-03-04:05:06", &ss)) << ss; 870 EXPECT_FALSE(absl::ParseLenientCivilTime("2015:02:03T04-05-06", &ss)) << ss; 871 EXPECT_FALSE(absl::ParseLenientCivilTime("9223372036854775808", &y)) << y; 872 } 873 874 TEST(CivilTime, AbslStringify) { 875 EXPECT_EQ("2015-01-02T03:04:05", 876 absl::StrFormat("%v", absl::CivilSecond(2015, 1, 2, 3, 4, 5))); 877 878 EXPECT_EQ("2015-01-02T03:04", 879 absl::StrFormat("%v", absl::CivilMinute(2015, 1, 2, 3, 4))); 880 881 EXPECT_EQ("2015-01-02T03", 882 absl::StrFormat("%v", absl::CivilHour(2015, 1, 2, 3))); 883 884 EXPECT_EQ("2015-01-02", absl::StrFormat("%v", absl::CivilDay(2015, 1, 2))); 885 886 EXPECT_EQ("2015-01", absl::StrFormat("%v", absl::CivilMonth(2015, 1))); 887 888 EXPECT_EQ("2015", absl::StrFormat("%v", absl::CivilYear(2015))); 889 } 890 891 TEST(CivilTime, OutputStream) { 892 absl::CivilSecond cs(2016, 2, 3, 4, 5, 6); 893 { 894 std::stringstream ss; 895 ss << std::left << std::setfill('.'); 896 ss << std::setw(3) << 'X'; 897 ss << std::setw(21) << absl::CivilYear(cs); 898 ss << std::setw(3) << 'X'; 899 EXPECT_EQ("X..2016.................X..", ss.str()); 900 } 901 { 902 std::stringstream ss; 903 ss << std::left << std::setfill('.'); 904 ss << std::setw(3) << 'X'; 905 ss << std::setw(21) << absl::CivilMonth(cs); 906 ss << std::setw(3) << 'X'; 907 EXPECT_EQ("X..2016-02..............X..", ss.str()); 908 } 909 { 910 std::stringstream ss; 911 ss << std::left << std::setfill('.'); 912 ss << std::setw(3) << 'X'; 913 ss << std::setw(21) << absl::CivilDay(cs); 914 ss << std::setw(3) << 'X'; 915 EXPECT_EQ("X..2016-02-03...........X..", ss.str()); 916 } 917 { 918 std::stringstream ss; 919 ss << std::left << std::setfill('.'); 920 ss << std::setw(3) << 'X'; 921 ss << std::setw(21) << absl::CivilHour(cs); 922 ss << std::setw(3) << 'X'; 923 EXPECT_EQ("X..2016-02-03T04........X..", ss.str()); 924 } 925 { 926 std::stringstream ss; 927 ss << std::left << std::setfill('.'); 928 ss << std::setw(3) << 'X'; 929 ss << std::setw(21) << absl::CivilMinute(cs); 930 ss << std::setw(3) << 'X'; 931 EXPECT_EQ("X..2016-02-03T04:05.....X..", ss.str()); 932 } 933 { 934 std::stringstream ss; 935 ss << std::left << std::setfill('.'); 936 ss << std::setw(3) << 'X'; 937 ss << std::setw(21) << absl::CivilSecond(cs); 938 ss << std::setw(3) << 'X'; 939 EXPECT_EQ("X..2016-02-03T04:05:06..X..", ss.str()); 940 } 941 { 942 std::stringstream ss; 943 ss << std::left << std::setfill('.'); 944 ss << std::setw(3) << 'X'; 945 ss << std::setw(21) << absl::Weekday::wednesday; 946 ss << std::setw(3) << 'X'; 947 EXPECT_EQ("X..Wednesday............X..", ss.str()); 948 } 949 } 950 951 TEST(CivilTime, Weekday) { 952 absl::CivilDay d(1970, 1, 1); 953 EXPECT_EQ(absl::Weekday::thursday, absl::GetWeekday(d)) << d; 954 955 // We used to get this wrong for years < -30. 956 d = absl::CivilDay(-31, 12, 24); 957 EXPECT_EQ(absl::Weekday::wednesday, absl::GetWeekday(d)) << d; 958 } 959 960 TEST(CivilTime, NextPrevWeekday) { 961 // Jan 1, 1970 was a Thursday. 962 const absl::CivilDay thursday(1970, 1, 1); 963 964 // Thursday -> Thursday 965 absl::CivilDay d = absl::NextWeekday(thursday, absl::Weekday::thursday); 966 EXPECT_EQ(7, d - thursday) << d; 967 EXPECT_EQ(d - 14, absl::PrevWeekday(thursday, absl::Weekday::thursday)); 968 969 // Thursday -> Friday 970 d = absl::NextWeekday(thursday, absl::Weekday::friday); 971 EXPECT_EQ(1, d - thursday) << d; 972 EXPECT_EQ(d - 7, absl::PrevWeekday(thursday, absl::Weekday::friday)); 973 974 // Thursday -> Saturday 975 d = absl::NextWeekday(thursday, absl::Weekday::saturday); 976 EXPECT_EQ(2, d - thursday) << d; 977 EXPECT_EQ(d - 7, absl::PrevWeekday(thursday, absl::Weekday::saturday)); 978 979 // Thursday -> Sunday 980 d = absl::NextWeekday(thursday, absl::Weekday::sunday); 981 EXPECT_EQ(3, d - thursday) << d; 982 EXPECT_EQ(d - 7, absl::PrevWeekday(thursday, absl::Weekday::sunday)); 983 984 // Thursday -> Monday 985 d = absl::NextWeekday(thursday, absl::Weekday::monday); 986 EXPECT_EQ(4, d - thursday) << d; 987 EXPECT_EQ(d - 7, absl::PrevWeekday(thursday, absl::Weekday::monday)); 988 989 // Thursday -> Tuesday 990 d = absl::NextWeekday(thursday, absl::Weekday::tuesday); 991 EXPECT_EQ(5, d - thursday) << d; 992 EXPECT_EQ(d - 7, absl::PrevWeekday(thursday, absl::Weekday::tuesday)); 993 994 // Thursday -> Wednesday 995 d = absl::NextWeekday(thursday, absl::Weekday::wednesday); 996 EXPECT_EQ(6, d - thursday) << d; 997 EXPECT_EQ(d - 7, absl::PrevWeekday(thursday, absl::Weekday::wednesday)); 998 } 999 1000 // NOTE: Run this with --copt=-ftrapv to detect overflow problems. 1001 TEST(CivilTime, DifferenceWithHugeYear) { 1002 absl::CivilDay d1(9223372036854775807, 1, 1); 1003 absl::CivilDay d2(9223372036854775807, 12, 31); 1004 EXPECT_EQ(364, d2 - d1); 1005 1006 d1 = absl::CivilDay(-9223372036854775807 - 1, 1, 1); 1007 d2 = absl::CivilDay(-9223372036854775807 - 1, 12, 31); 1008 EXPECT_EQ(365, d2 - d1); 1009 1010 // Check the limits of the return value at the end of the year range. 1011 d1 = absl::CivilDay(9223372036854775807, 1, 1); 1012 d2 = absl::CivilDay(9198119301927009252, 6, 6); 1013 EXPECT_EQ(9223372036854775807, d1 - d2); 1014 d2 = d2 - 1; 1015 EXPECT_EQ(-9223372036854775807 - 1, d2 - d1); 1016 1017 // Check the limits of the return value at the start of the year range. 1018 d1 = absl::CivilDay(-9223372036854775807 - 1, 1, 1); 1019 d2 = absl::CivilDay(-9198119301927009254, 7, 28); 1020 EXPECT_EQ(9223372036854775807, d2 - d1); 1021 d2 = d2 + 1; 1022 EXPECT_EQ(-9223372036854775807 - 1, d1 - d2); 1023 1024 // Check the limits of the return value from either side of year 0. 1025 d1 = absl::CivilDay(-12626367463883278, 9, 3); 1026 d2 = absl::CivilDay(12626367463883277, 3, 28); 1027 EXPECT_EQ(9223372036854775807, d2 - d1); 1028 d2 = d2 + 1; 1029 EXPECT_EQ(-9223372036854775807 - 1, d1 - d2); 1030 } 1031 1032 // NOTE: Run this with --copt=-ftrapv to detect overflow problems. 1033 TEST(CivilTime, DifferenceNoIntermediateOverflow) { 1034 // The difference up to the minute field would be below the minimum 1035 // int64_t, but the 52 extra seconds brings us back to the minimum. 1036 absl::CivilSecond s1(-292277022657, 1, 27, 8, 29 - 1, 52); 1037 absl::CivilSecond s2(1970, 1, 1, 0, 0 - 1, 0); 1038 EXPECT_EQ(-9223372036854775807 - 1, s1 - s2); 1039 1040 // The difference up to the minute field would be above the maximum 1041 // int64_t, but the -53 extra seconds brings us back to the maximum. 1042 s1 = absl::CivilSecond(292277026596, 12, 4, 15, 30, 7 - 7); 1043 s2 = absl::CivilSecond(1970, 1, 1, 0, 0, 0 - 7); 1044 EXPECT_EQ(9223372036854775807, s1 - s2); 1045 } 1046 1047 TEST(CivilTime, NormalizeSimpleOverflow) { 1048 absl::CivilSecond cs; 1049 cs = absl::CivilSecond(2013, 11, 15, 16, 32, 59 + 1); 1050 EXPECT_EQ("2013-11-15T16:33:00", absl::FormatCivilTime(cs)); 1051 cs = absl::CivilSecond(2013, 11, 15, 16, 59 + 1, 14); 1052 EXPECT_EQ("2013-11-15T17:00:14", absl::FormatCivilTime(cs)); 1053 cs = absl::CivilSecond(2013, 11, 15, 23 + 1, 32, 14); 1054 EXPECT_EQ("2013-11-16T00:32:14", absl::FormatCivilTime(cs)); 1055 cs = absl::CivilSecond(2013, 11, 30 + 1, 16, 32, 14); 1056 EXPECT_EQ("2013-12-01T16:32:14", absl::FormatCivilTime(cs)); 1057 cs = absl::CivilSecond(2013, 12 + 1, 15, 16, 32, 14); 1058 EXPECT_EQ("2014-01-15T16:32:14", absl::FormatCivilTime(cs)); 1059 } 1060 1061 TEST(CivilTime, NormalizeSimpleUnderflow) { 1062 absl::CivilSecond cs; 1063 cs = absl::CivilSecond(2013, 11, 15, 16, 32, 0 - 1); 1064 EXPECT_EQ("2013-11-15T16:31:59", absl::FormatCivilTime(cs)); 1065 cs = absl::CivilSecond(2013, 11, 15, 16, 0 - 1, 14); 1066 EXPECT_EQ("2013-11-15T15:59:14", absl::FormatCivilTime(cs)); 1067 cs = absl::CivilSecond(2013, 11, 15, 0 - 1, 32, 14); 1068 EXPECT_EQ("2013-11-14T23:32:14", absl::FormatCivilTime(cs)); 1069 cs = absl::CivilSecond(2013, 11, 1 - 1, 16, 32, 14); 1070 EXPECT_EQ("2013-10-31T16:32:14", absl::FormatCivilTime(cs)); 1071 cs = absl::CivilSecond(2013, 1 - 1, 15, 16, 32, 14); 1072 EXPECT_EQ("2012-12-15T16:32:14", absl::FormatCivilTime(cs)); 1073 } 1074 1075 TEST(CivilTime, NormalizeMultipleOverflow) { 1076 absl::CivilSecond cs(2013, 12, 31, 23, 59, 59 + 1); 1077 EXPECT_EQ("2014-01-01T00:00:00", absl::FormatCivilTime(cs)); 1078 } 1079 1080 TEST(CivilTime, NormalizeMultipleUnderflow) { 1081 absl::CivilSecond cs(2014, 1, 1, 0, 0, 0 - 1); 1082 EXPECT_EQ("2013-12-31T23:59:59", absl::FormatCivilTime(cs)); 1083 } 1084 1085 TEST(CivilTime, NormalizeOverflowLimits) { 1086 absl::CivilSecond cs; 1087 1088 const int kintmax = std::numeric_limits<int>::max(); 1089 cs = absl::CivilSecond(0, kintmax, kintmax, kintmax, kintmax, kintmax); 1090 EXPECT_EQ("185085715-11-27T12:21:07", absl::FormatCivilTime(cs)); 1091 1092 const int kintmin = std::numeric_limits<int>::min(); 1093 cs = absl::CivilSecond(0, kintmin, kintmin, kintmin, kintmin, kintmin); 1094 EXPECT_EQ("-185085717-10-31T10:37:52", absl::FormatCivilTime(cs)); 1095 } 1096 1097 TEST(CivilTime, NormalizeComplexOverflow) { 1098 absl::CivilSecond cs; 1099 cs = absl::CivilSecond(2013, 11, 15, 16, 32, 14 + 123456789); 1100 EXPECT_EQ("2017-10-14T14:05:23", absl::FormatCivilTime(cs)); 1101 cs = absl::CivilSecond(2013, 11, 15, 16, 32 + 1234567, 14); 1102 EXPECT_EQ("2016-03-22T00:39:14", absl::FormatCivilTime(cs)); 1103 cs = absl::CivilSecond(2013, 11, 15, 16 + 123456, 32, 14); 1104 EXPECT_EQ("2027-12-16T16:32:14", absl::FormatCivilTime(cs)); 1105 cs = absl::CivilSecond(2013, 11, 15 + 1234, 16, 32, 14); 1106 EXPECT_EQ("2017-04-02T16:32:14", absl::FormatCivilTime(cs)); 1107 cs = absl::CivilSecond(2013, 11 + 123, 15, 16, 32, 14); 1108 EXPECT_EQ("2024-02-15T16:32:14", absl::FormatCivilTime(cs)); 1109 } 1110 1111 TEST(CivilTime, NormalizeComplexUnderflow) { 1112 absl::CivilSecond cs; 1113 cs = absl::CivilSecond(1999, 3, 0, 0, 0, 0); // year 400 1114 EXPECT_EQ("1999-02-28T00:00:00", absl::FormatCivilTime(cs)); 1115 cs = absl::CivilSecond(2013, 11, 15, 16, 32, 14 - 123456789); 1116 EXPECT_EQ("2009-12-17T18:59:05", absl::FormatCivilTime(cs)); 1117 cs = absl::CivilSecond(2013, 11, 15, 16, 32 - 1234567, 14); 1118 EXPECT_EQ("2011-07-12T08:25:14", absl::FormatCivilTime(cs)); 1119 cs = absl::CivilSecond(2013, 11, 15, 16 - 123456, 32, 14); 1120 EXPECT_EQ("1999-10-16T16:32:14", absl::FormatCivilTime(cs)); 1121 cs = absl::CivilSecond(2013, 11, 15 - 1234, 16, 32, 14); 1122 EXPECT_EQ("2010-06-30T16:32:14", absl::FormatCivilTime(cs)); 1123 cs = absl::CivilSecond(2013, 11 - 123, 15, 16, 32, 14); 1124 EXPECT_EQ("2003-08-15T16:32:14", absl::FormatCivilTime(cs)); 1125 } 1126 1127 TEST(CivilTime, NormalizeMishmash) { 1128 absl::CivilSecond cs; 1129 cs = absl::CivilSecond(2013, 11 - 123, 15 + 1234, 16 - 123456, 32 + 1234567, 1130 14 - 123456789); 1131 EXPECT_EQ("1991-05-09T03:06:05", absl::FormatCivilTime(cs)); 1132 cs = absl::CivilSecond(2013, 11 + 123, 15 - 1234, 16 + 123456, 32 - 1234567, 1133 14 + 123456789); 1134 EXPECT_EQ("2036-05-24T05:58:23", absl::FormatCivilTime(cs)); 1135 1136 cs = absl::CivilSecond(2013, 11, -146097 + 1, 16, 32, 14); 1137 EXPECT_EQ("1613-11-01T16:32:14", absl::FormatCivilTime(cs)); 1138 cs = absl::CivilSecond(2013, 11 + 400 * 12, -146097 + 1, 16, 32, 14); 1139 EXPECT_EQ("2013-11-01T16:32:14", absl::FormatCivilTime(cs)); 1140 } 1141 1142 // Convert all the days from 1970-1-1 to 1970-1-146097 (aka 2369-12-31) 1143 // and check that they normalize to the expected time. 146097 days span 1144 // the 400-year Gregorian cycle used during normalization. 1145 TEST(CivilTime, NormalizeAllTheDays) { 1146 absl::CivilDay expected(1970, 1, 1); 1147 for (int day = 1; day <= 146097; ++day) { 1148 absl::CivilSecond cs(1970, 1, day, 0, 0, 0); 1149 EXPECT_EQ(expected, cs); 1150 ++expected; 1151 } 1152 } 1153 1154 TEST(CivilTime, NormalizeWithHugeYear) { 1155 absl::CivilMonth c(9223372036854775807, 1); 1156 EXPECT_EQ("9223372036854775807-01", absl::FormatCivilTime(c)); 1157 c = c - 1; // Causes normalization 1158 EXPECT_EQ("9223372036854775806-12", absl::FormatCivilTime(c)); 1159 1160 c = absl::CivilMonth(-9223372036854775807 - 1, 1); 1161 EXPECT_EQ("-9223372036854775808-01", absl::FormatCivilTime(c)); 1162 c = c + 12; // Causes normalization 1163 EXPECT_EQ("-9223372036854775807-01", absl::FormatCivilTime(c)); 1164 } 1165 1166 TEST(CivilTime, LeapYears) { 1167 const absl::CivilSecond s1(2013, 2, 28 + 1, 0, 0, 0); 1168 EXPECT_EQ("2013-03-01T00:00:00", absl::FormatCivilTime(s1)); 1169 1170 const absl::CivilSecond s2(2012, 2, 28 + 1, 0, 0, 0); 1171 EXPECT_EQ("2012-02-29T00:00:00", absl::FormatCivilTime(s2)); 1172 1173 const absl::CivilSecond s3(1900, 2, 28 + 1, 0, 0, 0); 1174 EXPECT_EQ("1900-03-01T00:00:00", absl::FormatCivilTime(s3)); 1175 1176 const struct { 1177 int year; 1178 int days; 1179 struct { 1180 int month; 1181 int day; 1182 } leap_day; // The date of the day after Feb 28. 1183 } kLeapYearTable[]{ 1184 {1900, 365, {3, 1}}, 1185 {1999, 365, {3, 1}}, 1186 {2000, 366, {2, 29}}, // leap year 1187 {2001, 365, {3, 1}}, 1188 {2002, 365, {3, 1}}, 1189 {2003, 365, {3, 1}}, 1190 {2004, 366, {2, 29}}, // leap year 1191 {2005, 365, {3, 1}}, 1192 {2006, 365, {3, 1}}, 1193 {2007, 365, {3, 1}}, 1194 {2008, 366, {2, 29}}, // leap year 1195 {2009, 365, {3, 1}}, 1196 {2100, 365, {3, 1}}, 1197 }; 1198 1199 for (int i = 0; i < ABSL_ARRAYSIZE(kLeapYearTable); ++i) { 1200 const int y = kLeapYearTable[i].year; 1201 const int m = kLeapYearTable[i].leap_day.month; 1202 const int d = kLeapYearTable[i].leap_day.day; 1203 const int n = kLeapYearTable[i].days; 1204 1205 // Tests incrementing through the leap day. 1206 const absl::CivilDay feb28(y, 2, 28); 1207 const absl::CivilDay next_day = feb28 + 1; 1208 EXPECT_EQ(m, next_day.month()); 1209 EXPECT_EQ(d, next_day.day()); 1210 1211 // Tests difference in days of leap years. 1212 const absl::CivilYear year(feb28); 1213 const absl::CivilYear next_year = year + 1; 1214 EXPECT_EQ(n, absl::CivilDay(next_year) - absl::CivilDay(year)); 1215 } 1216 } 1217 1218 TEST(CivilTime, FirstThursdayInMonth) { 1219 const absl::CivilDay nov1(2014, 11, 1); 1220 const absl::CivilDay thursday = 1221 absl::NextWeekday(nov1 - 1, absl::Weekday::thursday); 1222 EXPECT_EQ("2014-11-06", absl::FormatCivilTime(thursday)); 1223 1224 // Bonus: Date of Thanksgiving in the United States 1225 // Rule: Fourth Thursday of November 1226 const absl::CivilDay thanksgiving = thursday + 7 * 3; 1227 EXPECT_EQ("2014-11-27", absl::FormatCivilTime(thanksgiving)); 1228 } 1229 1230 TEST(CivilTime, DocumentationExample) { 1231 absl::CivilSecond second(2015, 6, 28, 1, 2, 3); // 2015-06-28 01:02:03 1232 absl::CivilMinute minute(second); // 2015-06-28 01:02:00 1233 absl::CivilDay day(minute); // 2015-06-28 00:00:00 1234 1235 second -= 1; // 2015-06-28 01:02:02 1236 --second; // 2015-06-28 01:02:01 1237 EXPECT_EQ(minute, second - 1); // Comparison between types 1238 EXPECT_LT(minute, second); 1239 1240 // int diff = second - minute; // ERROR: Mixed types, won't compile 1241 1242 absl::CivilDay june_1(2015, 6, 1); // Pass fields to c'tor. 1243 int diff = day - june_1; // Num days between 'day' and June 1 1244 EXPECT_EQ(27, diff); 1245 1246 // Fields smaller than alignment are floored to their minimum value. 1247 absl::CivilDay day_floor(2015, 1, 2, 9, 9, 9); 1248 EXPECT_EQ(0, day_floor.hour()); // 09:09:09 is floored 1249 EXPECT_EQ(absl::CivilDay(2015, 1, 2), day_floor); 1250 1251 // Unspecified fields default to their minimum value 1252 absl::CivilDay day_default(2015); // Defaults to Jan 1 1253 EXPECT_EQ(absl::CivilDay(2015, 1, 1), day_default); 1254 1255 // Iterates all the days of June. 1256 absl::CivilMonth june(day); // CivilDay -> CivilMonth 1257 absl::CivilMonth july = june + 1; 1258 for (absl::CivilDay day = june_1; day < july; ++day) { 1259 // ... 1260 } 1261 } 1262 1263 TEST(CivilTime, SupportsHash) { 1264 // To check that every field is used by the hash implementation, test 1265 // with values that have all fields the same bar one, for each field. 1266 1267 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1268 absl::CivilYear(2017), 1269 absl::CivilYear(2018), 1270 })); 1271 1272 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1273 absl::CivilMonth(2017, 1), 1274 absl::CivilMonth(2017, 2), 1275 absl::CivilMonth(2018, 1), 1276 absl::CivilMonth(2018, 2), 1277 })); 1278 1279 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1280 absl::CivilDay(2017, 1, 1), 1281 absl::CivilDay(2017, 1, 2), 1282 absl::CivilDay(2017, 2, 1), 1283 absl::CivilDay(2017, 2, 2), 1284 absl::CivilDay(2018, 1, 1), 1285 absl::CivilDay(2018, 1, 2), 1286 absl::CivilDay(2018, 2, 1), 1287 absl::CivilDay(2018, 2, 2), 1288 })); 1289 1290 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1291 absl::CivilHour(2017, 1, 1, 0), 1292 absl::CivilHour(2017, 1, 1, 1), 1293 absl::CivilHour(2017, 1, 2, 0), 1294 absl::CivilHour(2017, 1, 2, 1), 1295 absl::CivilHour(2017, 2, 1, 0), 1296 absl::CivilHour(2017, 2, 1, 1), 1297 absl::CivilHour(2017, 2, 2, 0), 1298 absl::CivilHour(2017, 2, 2, 1), 1299 absl::CivilHour(2018, 1, 1, 0), 1300 absl::CivilHour(2018, 1, 1, 1), 1301 absl::CivilHour(2018, 1, 2, 0), 1302 absl::CivilHour(2018, 1, 2, 1), 1303 absl::CivilHour(2018, 2, 1, 0), 1304 absl::CivilHour(2018, 2, 1, 1), 1305 absl::CivilHour(2018, 2, 2, 0), 1306 absl::CivilHour(2018, 2, 2, 1), 1307 })); 1308 1309 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1310 absl::CivilMinute(2017, 1, 1, 0, 0), absl::CivilMinute(2017, 1, 1, 0, 1), 1311 absl::CivilMinute(2017, 1, 1, 1, 0), absl::CivilMinute(2017, 1, 1, 1, 1), 1312 absl::CivilMinute(2017, 1, 2, 0, 0), absl::CivilMinute(2017, 1, 2, 0, 1), 1313 absl::CivilMinute(2017, 1, 2, 1, 0), absl::CivilMinute(2017, 1, 2, 1, 1), 1314 absl::CivilMinute(2017, 2, 1, 0, 0), absl::CivilMinute(2017, 2, 1, 0, 1), 1315 absl::CivilMinute(2017, 2, 1, 1, 0), absl::CivilMinute(2017, 2, 1, 1, 1), 1316 absl::CivilMinute(2017, 2, 2, 0, 0), absl::CivilMinute(2017, 2, 2, 0, 1), 1317 absl::CivilMinute(2017, 2, 2, 1, 0), absl::CivilMinute(2017, 2, 2, 1, 1), 1318 absl::CivilMinute(2018, 1, 1, 0, 0), absl::CivilMinute(2018, 1, 1, 0, 1), 1319 absl::CivilMinute(2018, 1, 1, 1, 0), absl::CivilMinute(2018, 1, 1, 1, 1), 1320 absl::CivilMinute(2018, 1, 2, 0, 0), absl::CivilMinute(2018, 1, 2, 0, 1), 1321 absl::CivilMinute(2018, 1, 2, 1, 0), absl::CivilMinute(2018, 1, 2, 1, 1), 1322 absl::CivilMinute(2018, 2, 1, 0, 0), absl::CivilMinute(2018, 2, 1, 0, 1), 1323 absl::CivilMinute(2018, 2, 1, 1, 0), absl::CivilMinute(2018, 2, 1, 1, 1), 1324 absl::CivilMinute(2018, 2, 2, 0, 0), absl::CivilMinute(2018, 2, 2, 0, 1), 1325 absl::CivilMinute(2018, 2, 2, 1, 0), absl::CivilMinute(2018, 2, 2, 1, 1), 1326 })); 1327 1328 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1329 absl::CivilSecond(2017, 1, 1, 0, 0, 0), 1330 absl::CivilSecond(2017, 1, 1, 0, 0, 1), 1331 absl::CivilSecond(2017, 1, 1, 0, 1, 0), 1332 absl::CivilSecond(2017, 1, 1, 0, 1, 1), 1333 absl::CivilSecond(2017, 1, 1, 1, 0, 0), 1334 absl::CivilSecond(2017, 1, 1, 1, 0, 1), 1335 absl::CivilSecond(2017, 1, 1, 1, 1, 0), 1336 absl::CivilSecond(2017, 1, 1, 1, 1, 1), 1337 absl::CivilSecond(2017, 1, 2, 0, 0, 0), 1338 absl::CivilSecond(2017, 1, 2, 0, 0, 1), 1339 absl::CivilSecond(2017, 1, 2, 0, 1, 0), 1340 absl::CivilSecond(2017, 1, 2, 0, 1, 1), 1341 absl::CivilSecond(2017, 1, 2, 1, 0, 0), 1342 absl::CivilSecond(2017, 1, 2, 1, 0, 1), 1343 absl::CivilSecond(2017, 1, 2, 1, 1, 0), 1344 absl::CivilSecond(2017, 1, 2, 1, 1, 1), 1345 absl::CivilSecond(2017, 2, 1, 0, 0, 0), 1346 absl::CivilSecond(2017, 2, 1, 0, 0, 1), 1347 absl::CivilSecond(2017, 2, 1, 0, 1, 0), 1348 absl::CivilSecond(2017, 2, 1, 0, 1, 1), 1349 absl::CivilSecond(2017, 2, 1, 1, 0, 0), 1350 absl::CivilSecond(2017, 2, 1, 1, 0, 1), 1351 absl::CivilSecond(2017, 2, 1, 1, 1, 0), 1352 absl::CivilSecond(2017, 2, 1, 1, 1, 1), 1353 absl::CivilSecond(2017, 2, 2, 0, 0, 0), 1354 absl::CivilSecond(2017, 2, 2, 0, 0, 1), 1355 absl::CivilSecond(2017, 2, 2, 0, 1, 0), 1356 absl::CivilSecond(2017, 2, 2, 0, 1, 1), 1357 absl::CivilSecond(2017, 2, 2, 1, 0, 0), 1358 absl::CivilSecond(2017, 2, 2, 1, 0, 1), 1359 absl::CivilSecond(2017, 2, 2, 1, 1, 0), 1360 absl::CivilSecond(2017, 2, 2, 1, 1, 1), 1361 absl::CivilSecond(2018, 1, 1, 0, 0, 0), 1362 absl::CivilSecond(2018, 1, 1, 0, 0, 1), 1363 absl::CivilSecond(2018, 1, 1, 0, 1, 0), 1364 absl::CivilSecond(2018, 1, 1, 0, 1, 1), 1365 absl::CivilSecond(2018, 1, 1, 1, 0, 0), 1366 absl::CivilSecond(2018, 1, 1, 1, 0, 1), 1367 absl::CivilSecond(2018, 1, 1, 1, 1, 0), 1368 absl::CivilSecond(2018, 1, 1, 1, 1, 1), 1369 absl::CivilSecond(2018, 1, 2, 0, 0, 0), 1370 absl::CivilSecond(2018, 1, 2, 0, 0, 1), 1371 absl::CivilSecond(2018, 1, 2, 0, 1, 0), 1372 absl::CivilSecond(2018, 1, 2, 0, 1, 1), 1373 absl::CivilSecond(2018, 1, 2, 1, 0, 0), 1374 absl::CivilSecond(2018, 1, 2, 1, 0, 1), 1375 absl::CivilSecond(2018, 1, 2, 1, 1, 0), 1376 absl::CivilSecond(2018, 1, 2, 1, 1, 1), 1377 absl::CivilSecond(2018, 2, 1, 0, 0, 0), 1378 absl::CivilSecond(2018, 2, 1, 0, 0, 1), 1379 absl::CivilSecond(2018, 2, 1, 0, 1, 0), 1380 absl::CivilSecond(2018, 2, 1, 0, 1, 1), 1381 absl::CivilSecond(2018, 2, 1, 1, 0, 0), 1382 absl::CivilSecond(2018, 2, 1, 1, 0, 1), 1383 absl::CivilSecond(2018, 2, 1, 1, 1, 0), 1384 absl::CivilSecond(2018, 2, 1, 1, 1, 1), 1385 absl::CivilSecond(2018, 2, 2, 0, 0, 0), 1386 absl::CivilSecond(2018, 2, 2, 0, 0, 1), 1387 absl::CivilSecond(2018, 2, 2, 0, 1, 0), 1388 absl::CivilSecond(2018, 2, 2, 0, 1, 1), 1389 absl::CivilSecond(2018, 2, 2, 1, 0, 0), 1390 absl::CivilSecond(2018, 2, 2, 1, 0, 1), 1391 absl::CivilSecond(2018, 2, 2, 1, 1, 0), 1392 absl::CivilSecond(2018, 2, 2, 1, 1, 1), 1393 })); 1394 } 1395 1396 } // namespace