time_test.cc (54531B)
1 // Copyright 2017 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/time.h" 16 #include "absl/time/civil_time.h" 17 18 #if defined(_MSC_VER) 19 #include <winsock2.h> // for timeval 20 #endif 21 22 #include "absl/base/config.h" 23 24 // For feature testing and determining which headers can be included. 25 #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L 26 #include <version> 27 #endif 28 29 #include <chrono> // NOLINT(build/c++11) 30 #ifdef __cpp_lib_three_way_comparison 31 #include <compare> 32 #endif // __cpp_lib_three_way_comparison 33 #include <cstdint> 34 #include <cstring> 35 #include <ctime> 36 #include <iomanip> 37 #include <ios> 38 #include <limits> 39 #include <string> 40 #include <type_traits> 41 42 #include "gmock/gmock.h" 43 #include "gtest/gtest.h" 44 #include "absl/hash/hash_testing.h" 45 #include "absl/numeric/int128.h" 46 #include "absl/strings/str_format.h" 47 #include "absl/time/clock.h" 48 #include "absl/time/internal/test_util.h" 49 50 namespace { 51 52 #if defined(GTEST_USES_SIMPLE_RE) && GTEST_USES_SIMPLE_RE 53 const char kZoneAbbrRE[] = ".*"; // just punt 54 #else 55 const char kZoneAbbrRE[] = "[A-Za-z]{3,4}|[-+][0-9]{2}([0-9]{2})?"; 56 #endif 57 58 // This helper is a macro so that failed expectations show up with the 59 // correct line numbers. 60 #define EXPECT_CIVIL_INFO(ci, y, m, d, h, min, s, off, isdst) \ 61 do { \ 62 EXPECT_EQ(y, ci.cs.year()); \ 63 EXPECT_EQ(m, ci.cs.month()); \ 64 EXPECT_EQ(d, ci.cs.day()); \ 65 EXPECT_EQ(h, ci.cs.hour()); \ 66 EXPECT_EQ(min, ci.cs.minute()); \ 67 EXPECT_EQ(s, ci.cs.second()); \ 68 EXPECT_EQ(off, ci.offset); \ 69 EXPECT_EQ(isdst, ci.is_dst); \ 70 EXPECT_THAT(ci.zone_abbr, testing::MatchesRegex(kZoneAbbrRE)); \ 71 } while (0) 72 73 // A gMock matcher to match timespec values. Use this matcher like: 74 // timespec ts1, ts2; 75 // EXPECT_THAT(ts1, TimespecMatcher(ts2)); 76 MATCHER_P(TimespecMatcher, ts, "") { 77 if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec) return true; 78 *result_listener << "expected: {" << ts.tv_sec << ", " << ts.tv_nsec << "} "; 79 *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_nsec << "}"; 80 return false; 81 } 82 83 // A gMock matcher to match timeval values. Use this matcher like: 84 // timeval tv1, tv2; 85 // EXPECT_THAT(tv1, TimevalMatcher(tv2)); 86 MATCHER_P(TimevalMatcher, tv, "") { 87 if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec) return true; 88 *result_listener << "expected: {" << tv.tv_sec << ", " << tv.tv_usec << "} "; 89 *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_usec << "}"; 90 return false; 91 } 92 93 TEST(Time, ConstExpr) { 94 static_assert(std::is_trivially_destructible<absl::Time>::value, 95 "Time is documented as being trivially destructible"); 96 constexpr absl::Time t0 = absl::UnixEpoch(); 97 static_assert(t0 == absl::UnixEpoch(), "UnixEpoch"); 98 constexpr absl::Time t1 = absl::InfiniteFuture(); 99 static_assert(t1 != absl::UnixEpoch(), "InfiniteFuture"); 100 constexpr absl::Time t2 = absl::InfinitePast(); 101 static_assert(t2 != absl::UnixEpoch(), "InfinitePast"); 102 constexpr absl::Time t3 = absl::FromUnixNanos(0); 103 static_assert(t3 == absl::UnixEpoch(), "FromUnixNanos"); 104 constexpr absl::Time t4 = absl::FromUnixMicros(0); 105 static_assert(t4 == absl::UnixEpoch(), "FromUnixMicros"); 106 constexpr absl::Time t5 = absl::FromUnixMillis(0); 107 static_assert(t5 == absl::UnixEpoch(), "FromUnixMillis"); 108 constexpr absl::Time t6 = absl::FromUnixSeconds(0); 109 static_assert(t6 == absl::UnixEpoch(), "FromUnixSeconds"); 110 constexpr absl::Time t7 = absl::FromTimeT(0); 111 static_assert(t7 == absl::UnixEpoch(), "FromTimeT"); 112 } 113 114 TEST(Time, ValueSemantics) { 115 absl::Time a; // Default construction 116 absl::Time b = a; // Copy construction 117 EXPECT_EQ(a, b); 118 absl::Time c(a); // Copy construction (again) 119 EXPECT_EQ(a, b); 120 EXPECT_EQ(a, c); 121 EXPECT_EQ(b, c); 122 b = c; // Assignment 123 EXPECT_EQ(a, b); 124 EXPECT_EQ(a, c); 125 EXPECT_EQ(b, c); 126 } 127 128 TEST(Time, UnixEpoch) { 129 const auto ci = absl::UTCTimeZone().At(absl::UnixEpoch()); 130 EXPECT_EQ(absl::CivilSecond(1970, 1, 1, 0, 0, 0), ci.cs); 131 EXPECT_EQ(absl::ZeroDuration(), ci.subsecond); 132 EXPECT_EQ(absl::Weekday::thursday, absl::GetWeekday(ci.cs)); 133 } 134 135 TEST(Time, Breakdown) { 136 absl::TimeZone tz = absl::time_internal::LoadTimeZone("America/New_York"); 137 absl::Time t = absl::UnixEpoch(); 138 139 // The Unix epoch as seen in NYC. 140 auto ci = tz.At(t); 141 EXPECT_CIVIL_INFO(ci, 1969, 12, 31, 19, 0, 0, -18000, false); 142 EXPECT_EQ(absl::ZeroDuration(), ci.subsecond); 143 EXPECT_EQ(absl::Weekday::wednesday, absl::GetWeekday(ci.cs)); 144 145 // Just before the epoch. 146 t -= absl::Nanoseconds(1); 147 ci = tz.At(t); 148 EXPECT_CIVIL_INFO(ci, 1969, 12, 31, 18, 59, 59, -18000, false); 149 EXPECT_EQ(absl::Nanoseconds(999999999), ci.subsecond); 150 EXPECT_EQ(absl::Weekday::wednesday, absl::GetWeekday(ci.cs)); 151 152 // Some time later. 153 t += absl::Hours(24) * 2735; 154 t += absl::Hours(18) + absl::Minutes(30) + absl::Seconds(15) + 155 absl::Nanoseconds(9); 156 ci = tz.At(t); 157 EXPECT_CIVIL_INFO(ci, 1977, 6, 28, 14, 30, 15, -14400, true); 158 EXPECT_EQ(8, ci.subsecond / absl::Nanoseconds(1)); 159 EXPECT_EQ(absl::Weekday::tuesday, absl::GetWeekday(ci.cs)); 160 } 161 162 TEST(Time, AdditiveOperators) { 163 const absl::Duration d = absl::Nanoseconds(1); 164 const absl::Time t0; 165 const absl::Time t1 = t0 + d; 166 167 EXPECT_EQ(d, t1 - t0); 168 EXPECT_EQ(-d, t0 - t1); 169 EXPECT_EQ(t0, t1 - d); 170 171 absl::Time t(t0); 172 EXPECT_EQ(t0, t); 173 t += d; 174 EXPECT_EQ(t0 + d, t); 175 EXPECT_EQ(d, t - t0); 176 t -= d; 177 EXPECT_EQ(t0, t); 178 179 // Tests overflow between subseconds and seconds. 180 t = absl::UnixEpoch(); 181 t += absl::Milliseconds(500); 182 EXPECT_EQ(absl::UnixEpoch() + absl::Milliseconds(500), t); 183 t += absl::Milliseconds(600); 184 EXPECT_EQ(absl::UnixEpoch() + absl::Milliseconds(1100), t); 185 t -= absl::Milliseconds(600); 186 EXPECT_EQ(absl::UnixEpoch() + absl::Milliseconds(500), t); 187 t -= absl::Milliseconds(500); 188 EXPECT_EQ(absl::UnixEpoch(), t); 189 } 190 191 TEST(Time, RelationalOperators) { 192 constexpr absl::Time t1 = absl::FromUnixNanos(0); 193 constexpr absl::Time t2 = absl::FromUnixNanos(1); 194 constexpr absl::Time t3 = absl::FromUnixNanos(2); 195 196 static_assert(absl::UnixEpoch() == t1, ""); 197 static_assert(t1 == t1, ""); 198 static_assert(t2 == t2, ""); 199 static_assert(t3 == t3, ""); 200 201 static_assert(t1 < t2, ""); 202 static_assert(t2 < t3, ""); 203 static_assert(t1 < t3, ""); 204 205 static_assert(t1 <= t1, ""); 206 static_assert(t1 <= t2, ""); 207 static_assert(t2 <= t2, ""); 208 static_assert(t2 <= t3, ""); 209 static_assert(t3 <= t3, ""); 210 static_assert(t1 <= t3, ""); 211 212 static_assert(t2 > t1, ""); 213 static_assert(t3 > t2, ""); 214 static_assert(t3 > t1, ""); 215 216 static_assert(t2 >= t2, ""); 217 static_assert(t2 >= t1, ""); 218 static_assert(t3 >= t3, ""); 219 static_assert(t3 >= t2, ""); 220 static_assert(t1 >= t1, ""); 221 static_assert(t3 >= t1, ""); 222 223 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON 224 225 static_assert((t1 <=> t1) == std::strong_ordering::equal, ""); 226 static_assert((t2 <=> t2) == std::strong_ordering::equal, ""); 227 static_assert((t3 <=> t3) == std::strong_ordering::equal, ""); 228 229 static_assert((t1 <=> t2) == std::strong_ordering::less, ""); 230 static_assert((t2 <=> t3) == std::strong_ordering::less, ""); 231 static_assert((t1 <=> t3) == std::strong_ordering::less, ""); 232 233 static_assert((t2 <=> t1) == std::strong_ordering::greater, ""); 234 static_assert((t3 <=> t2) == std::strong_ordering::greater, ""); 235 static_assert((t3 <=> t1) == std::strong_ordering::greater, ""); 236 237 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON 238 } 239 240 TEST(Time, Infinity) { 241 constexpr absl::Time ifuture = absl::InfiniteFuture(); 242 constexpr absl::Time ipast = absl::InfinitePast(); 243 244 static_assert(ifuture == ifuture, ""); 245 static_assert(ipast == ipast, ""); 246 static_assert(ipast < ifuture, ""); 247 static_assert(ifuture > ipast, ""); 248 249 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON 250 251 static_assert((ifuture <=> ifuture) == std::strong_ordering::equal, ""); 252 static_assert((ipast <=> ipast) == std::strong_ordering::equal, ""); 253 static_assert((ipast <=> ifuture) == std::strong_ordering::less, ""); 254 static_assert((ifuture <=> ipast) == std::strong_ordering::greater, ""); 255 256 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON 257 258 // Arithmetic saturates 259 EXPECT_EQ(ifuture, ifuture + absl::Seconds(1)); 260 EXPECT_EQ(ifuture, ifuture - absl::Seconds(1)); 261 EXPECT_EQ(ipast, ipast + absl::Seconds(1)); 262 EXPECT_EQ(ipast, ipast - absl::Seconds(1)); 263 264 EXPECT_EQ(absl::InfiniteDuration(), ifuture - ifuture); 265 EXPECT_EQ(absl::InfiniteDuration(), ifuture - ipast); 266 EXPECT_EQ(-absl::InfiniteDuration(), ipast - ifuture); 267 EXPECT_EQ(-absl::InfiniteDuration(), ipast - ipast); 268 269 constexpr absl::Time t = absl::UnixEpoch(); // Any finite time. 270 static_assert(t < ifuture, ""); 271 static_assert(t > ipast, ""); 272 273 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON 274 275 static_assert((t <=> ifuture) == std::strong_ordering::less, ""); 276 static_assert((t <=> ipast) == std::strong_ordering::greater, ""); 277 static_assert((ipast <=> t) == std::strong_ordering::less, ""); 278 static_assert((ifuture <=> t) == std::strong_ordering::greater, ""); 279 280 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON 281 282 EXPECT_EQ(ifuture, t + absl::InfiniteDuration()); 283 EXPECT_EQ(ipast, t - absl::InfiniteDuration()); 284 } 285 286 TEST(Time, FloorConversion) { 287 #define TEST_FLOOR_CONVERSION(TO, FROM) \ 288 EXPECT_EQ(1, TO(FROM(1001))); \ 289 EXPECT_EQ(1, TO(FROM(1000))); \ 290 EXPECT_EQ(0, TO(FROM(999))); \ 291 EXPECT_EQ(0, TO(FROM(1))); \ 292 EXPECT_EQ(0, TO(FROM(0))); \ 293 EXPECT_EQ(-1, TO(FROM(-1))); \ 294 EXPECT_EQ(-1, TO(FROM(-999))); \ 295 EXPECT_EQ(-1, TO(FROM(-1000))); \ 296 EXPECT_EQ(-2, TO(FROM(-1001))); 297 298 TEST_FLOOR_CONVERSION(absl::ToUnixMicros, absl::FromUnixNanos); 299 TEST_FLOOR_CONVERSION(absl::ToUnixMillis, absl::FromUnixMicros); 300 TEST_FLOOR_CONVERSION(absl::ToUnixSeconds, absl::FromUnixMillis); 301 TEST_FLOOR_CONVERSION(absl::ToTimeT, absl::FromUnixMillis); 302 303 #undef TEST_FLOOR_CONVERSION 304 305 // Tests ToUnixNanos. 306 EXPECT_EQ(1, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(3) / 2)); 307 EXPECT_EQ(1, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(1))); 308 EXPECT_EQ(0, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(1) / 2)); 309 EXPECT_EQ(0, absl::ToUnixNanos(absl::UnixEpoch() + absl::ZeroDuration())); 310 EXPECT_EQ(-1, 311 absl::ToUnixNanos(absl::UnixEpoch() - absl::Nanoseconds(1) / 2)); 312 EXPECT_EQ(-1, absl::ToUnixNanos(absl::UnixEpoch() - absl::Nanoseconds(1))); 313 EXPECT_EQ(-2, 314 absl::ToUnixNanos(absl::UnixEpoch() - absl::Nanoseconds(3) / 2)); 315 316 // Tests ToUniversal, which uses a different epoch than the tests above. 317 EXPECT_EQ(1, 318 absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(101))); 319 EXPECT_EQ(1, 320 absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(100))); 321 EXPECT_EQ(0, 322 absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(99))); 323 EXPECT_EQ(0, 324 absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(1))); 325 EXPECT_EQ(0, 326 absl::ToUniversal(absl::UniversalEpoch() + absl::ZeroDuration())); 327 EXPECT_EQ(-1, 328 absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-1))); 329 EXPECT_EQ(-1, 330 absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-99))); 331 EXPECT_EQ( 332 -1, absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-100))); 333 EXPECT_EQ( 334 -2, absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-101))); 335 336 // Tests ToTimespec()/TimeFromTimespec() 337 const struct { 338 absl::Time t; 339 timespec ts; 340 } to_ts[] = { 341 {absl::FromUnixSeconds(1) + absl::Nanoseconds(1), {1, 1}}, 342 {absl::FromUnixSeconds(1) + absl::Nanoseconds(1) / 2, {1, 0}}, 343 {absl::FromUnixSeconds(1) + absl::ZeroDuration(), {1, 0}}, 344 {absl::FromUnixSeconds(0) + absl::ZeroDuration(), {0, 0}}, 345 {absl::FromUnixSeconds(0) - absl::Nanoseconds(1) / 2, {-1, 999999999}}, 346 {absl::FromUnixSeconds(0) - absl::Nanoseconds(1), {-1, 999999999}}, 347 {absl::FromUnixSeconds(-1) + absl::Nanoseconds(1), {-1, 1}}, 348 {absl::FromUnixSeconds(-1) + absl::Nanoseconds(1) / 2, {-1, 0}}, 349 {absl::FromUnixSeconds(-1) + absl::ZeroDuration(), {-1, 0}}, 350 {absl::FromUnixSeconds(-1) - absl::Nanoseconds(1) / 2, {-2, 999999999}}, 351 }; 352 for (const auto& test : to_ts) { 353 EXPECT_THAT(absl::ToTimespec(test.t), TimespecMatcher(test.ts)); 354 } 355 const struct { 356 timespec ts; 357 absl::Time t; 358 } from_ts[] = { 359 {{1, 1}, absl::FromUnixSeconds(1) + absl::Nanoseconds(1)}, 360 {{1, 0}, absl::FromUnixSeconds(1) + absl::ZeroDuration()}, 361 {{0, 0}, absl::FromUnixSeconds(0) + absl::ZeroDuration()}, 362 {{0, -1}, absl::FromUnixSeconds(0) - absl::Nanoseconds(1)}, 363 {{-1, 999999999}, absl::FromUnixSeconds(0) - absl::Nanoseconds(1)}, 364 {{-1, 1}, absl::FromUnixSeconds(-1) + absl::Nanoseconds(1)}, 365 {{-1, 0}, absl::FromUnixSeconds(-1) + absl::ZeroDuration()}, 366 {{-1, -1}, absl::FromUnixSeconds(-1) - absl::Nanoseconds(1)}, 367 {{-2, 999999999}, absl::FromUnixSeconds(-1) - absl::Nanoseconds(1)}, 368 }; 369 for (const auto& test : from_ts) { 370 EXPECT_EQ(test.t, absl::TimeFromTimespec(test.ts)); 371 } 372 373 // Tests absl::ToTimeval()/TimeFromTimeval() (same as timespec above) 374 const struct { 375 absl::Time t; 376 timeval tv; 377 } to_tv[] = { 378 {absl::FromUnixSeconds(1) + absl::Microseconds(1), {1, 1}}, 379 {absl::FromUnixSeconds(1) + absl::Microseconds(1) / 2, {1, 0}}, 380 {absl::FromUnixSeconds(1) + absl::ZeroDuration(), {1, 0}}, 381 {absl::FromUnixSeconds(0) + absl::ZeroDuration(), {0, 0}}, 382 {absl::FromUnixSeconds(0) - absl::Microseconds(1) / 2, {-1, 999999}}, 383 {absl::FromUnixSeconds(0) - absl::Microseconds(1), {-1, 999999}}, 384 {absl::FromUnixSeconds(-1) + absl::Microseconds(1), {-1, 1}}, 385 {absl::FromUnixSeconds(-1) + absl::Microseconds(1) / 2, {-1, 0}}, 386 {absl::FromUnixSeconds(-1) + absl::ZeroDuration(), {-1, 0}}, 387 {absl::FromUnixSeconds(-1) - absl::Microseconds(1) / 2, {-2, 999999}}, 388 }; 389 for (const auto& test : to_tv) { 390 EXPECT_THAT(absl::ToTimeval(test.t), TimevalMatcher(test.tv)); 391 } 392 const struct { 393 timeval tv; 394 absl::Time t; 395 } from_tv[] = { 396 {{1, 1}, absl::FromUnixSeconds(1) + absl::Microseconds(1)}, 397 {{1, 0}, absl::FromUnixSeconds(1) + absl::ZeroDuration()}, 398 {{0, 0}, absl::FromUnixSeconds(0) + absl::ZeroDuration()}, 399 {{0, -1}, absl::FromUnixSeconds(0) - absl::Microseconds(1)}, 400 {{-1, 999999}, absl::FromUnixSeconds(0) - absl::Microseconds(1)}, 401 {{-1, 1}, absl::FromUnixSeconds(-1) + absl::Microseconds(1)}, 402 {{-1, 0}, absl::FromUnixSeconds(-1) + absl::ZeroDuration()}, 403 {{-1, -1}, absl::FromUnixSeconds(-1) - absl::Microseconds(1)}, 404 {{-2, 999999}, absl::FromUnixSeconds(-1) - absl::Microseconds(1)}, 405 }; 406 for (const auto& test : from_tv) { 407 EXPECT_EQ(test.t, absl::TimeFromTimeval(test.tv)); 408 } 409 410 // Tests flooring near negative infinity. 411 const int64_t min_plus_1 = std::numeric_limits<int64_t>::min() + 1; 412 EXPECT_EQ(min_plus_1, absl::ToUnixSeconds(absl::FromUnixSeconds(min_plus_1))); 413 EXPECT_EQ(std::numeric_limits<int64_t>::min(), 414 absl::ToUnixSeconds(absl::FromUnixSeconds(min_plus_1) - 415 absl::Nanoseconds(1) / 2)); 416 417 // Tests flooring near positive infinity. 418 EXPECT_EQ(std::numeric_limits<int64_t>::max(), 419 absl::ToUnixSeconds( 420 absl::FromUnixSeconds(std::numeric_limits<int64_t>::max()) + 421 absl::Nanoseconds(1) / 2)); 422 EXPECT_EQ(std::numeric_limits<int64_t>::max(), 423 absl::ToUnixSeconds( 424 absl::FromUnixSeconds(std::numeric_limits<int64_t>::max()))); 425 EXPECT_EQ(std::numeric_limits<int64_t>::max() - 1, 426 absl::ToUnixSeconds( 427 absl::FromUnixSeconds(std::numeric_limits<int64_t>::max()) - 428 absl::Nanoseconds(1) / 2)); 429 } 430 431 TEST(Time, RoundtripConversion) { 432 #define TEST_CONVERSION_ROUND_TRIP(SOURCE, FROM, TO, MATCHER) \ 433 EXPECT_THAT(TO(FROM(SOURCE)), MATCHER(SOURCE)) 434 435 // FromUnixNanos() and ToUnixNanos() 436 int64_t now_ns = absl::GetCurrentTimeNanos(); 437 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixNanos, absl::ToUnixNanos, 438 testing::Eq); 439 TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixNanos, absl::ToUnixNanos, 440 testing::Eq); 441 TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixNanos, absl::ToUnixNanos, 442 testing::Eq); 443 TEST_CONVERSION_ROUND_TRIP(now_ns, absl::FromUnixNanos, absl::ToUnixNanos, 444 testing::Eq) 445 << now_ns; 446 447 // FromUnixMicros() and ToUnixMicros() 448 int64_t now_us = absl::GetCurrentTimeNanos() / 1000; 449 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixMicros, absl::ToUnixMicros, 450 testing::Eq); 451 TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixMicros, absl::ToUnixMicros, 452 testing::Eq); 453 TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixMicros, absl::ToUnixMicros, 454 testing::Eq); 455 TEST_CONVERSION_ROUND_TRIP(now_us, absl::FromUnixMicros, absl::ToUnixMicros, 456 testing::Eq) 457 << now_us; 458 459 // FromUnixMillis() and ToUnixMillis() 460 int64_t now_ms = absl::GetCurrentTimeNanos() / 1000000; 461 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixMillis, absl::ToUnixMillis, 462 testing::Eq); 463 TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixMillis, absl::ToUnixMillis, 464 testing::Eq); 465 TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixMillis, absl::ToUnixMillis, 466 testing::Eq); 467 TEST_CONVERSION_ROUND_TRIP(now_ms, absl::FromUnixMillis, absl::ToUnixMillis, 468 testing::Eq) 469 << now_ms; 470 471 // FromUnixSeconds() and ToUnixSeconds() 472 int64_t now_s = std::time(nullptr); 473 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixSeconds, absl::ToUnixSeconds, 474 testing::Eq); 475 TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixSeconds, absl::ToUnixSeconds, 476 testing::Eq); 477 TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixSeconds, absl::ToUnixSeconds, 478 testing::Eq); 479 TEST_CONVERSION_ROUND_TRIP(now_s, absl::FromUnixSeconds, absl::ToUnixSeconds, 480 testing::Eq) 481 << now_s; 482 483 // FromTimeT() and ToTimeT() 484 time_t now_time_t = std::time(nullptr); 485 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromTimeT, absl::ToTimeT, testing::Eq); 486 TEST_CONVERSION_ROUND_TRIP(0, absl::FromTimeT, absl::ToTimeT, testing::Eq); 487 TEST_CONVERSION_ROUND_TRIP(1, absl::FromTimeT, absl::ToTimeT, testing::Eq); 488 TEST_CONVERSION_ROUND_TRIP(now_time_t, absl::FromTimeT, absl::ToTimeT, 489 testing::Eq) 490 << now_time_t; 491 492 // TimeFromTimeval() and absl::ToTimeval() 493 timeval tv; 494 tv.tv_sec = -1; 495 tv.tv_usec = 0; 496 TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval, 497 TimevalMatcher); 498 tv.tv_sec = -1; 499 tv.tv_usec = 999999; 500 TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval, 501 TimevalMatcher); 502 tv.tv_sec = 0; 503 tv.tv_usec = 0; 504 TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval, 505 TimevalMatcher); 506 tv.tv_sec = 0; 507 tv.tv_usec = 1; 508 TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval, 509 TimevalMatcher); 510 tv.tv_sec = 1; 511 tv.tv_usec = 0; 512 TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval, 513 TimevalMatcher); 514 515 // TimeFromTimespec() and ToTimespec() 516 timespec ts; 517 ts.tv_sec = -1; 518 ts.tv_nsec = 0; 519 TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec, 520 TimespecMatcher); 521 ts.tv_sec = -1; 522 ts.tv_nsec = 999999999; 523 TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec, 524 TimespecMatcher); 525 ts.tv_sec = 0; 526 ts.tv_nsec = 0; 527 TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec, 528 TimespecMatcher); 529 ts.tv_sec = 0; 530 ts.tv_nsec = 1; 531 TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec, 532 TimespecMatcher); 533 ts.tv_sec = 1; 534 ts.tv_nsec = 0; 535 TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec, 536 TimespecMatcher); 537 538 // FromUDate() and ToUDate() 539 double now_ud = absl::GetCurrentTimeNanos() / 1000000; 540 TEST_CONVERSION_ROUND_TRIP(-1.5, absl::FromUDate, absl::ToUDate, 541 testing::DoubleEq); 542 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUDate, absl::ToUDate, 543 testing::DoubleEq); 544 TEST_CONVERSION_ROUND_TRIP(-0.5, absl::FromUDate, absl::ToUDate, 545 testing::DoubleEq); 546 TEST_CONVERSION_ROUND_TRIP(0, absl::FromUDate, absl::ToUDate, 547 testing::DoubleEq); 548 TEST_CONVERSION_ROUND_TRIP(0.5, absl::FromUDate, absl::ToUDate, 549 testing::DoubleEq); 550 TEST_CONVERSION_ROUND_TRIP(1, absl::FromUDate, absl::ToUDate, 551 testing::DoubleEq); 552 TEST_CONVERSION_ROUND_TRIP(1.5, absl::FromUDate, absl::ToUDate, 553 testing::DoubleEq); 554 TEST_CONVERSION_ROUND_TRIP(now_ud, absl::FromUDate, absl::ToUDate, 555 testing::DoubleEq) 556 << std::fixed << std::setprecision(17) << now_ud; 557 558 // FromUniversal() and ToUniversal() 559 int64_t now_uni = ((719162LL * (24 * 60 * 60)) * (1000 * 1000 * 10)) + 560 (absl::GetCurrentTimeNanos() / 100); 561 TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUniversal, absl::ToUniversal, 562 testing::Eq); 563 TEST_CONVERSION_ROUND_TRIP(0, absl::FromUniversal, absl::ToUniversal, 564 testing::Eq); 565 TEST_CONVERSION_ROUND_TRIP(1, absl::FromUniversal, absl::ToUniversal, 566 testing::Eq); 567 TEST_CONVERSION_ROUND_TRIP(now_uni, absl::FromUniversal, absl::ToUniversal, 568 testing::Eq) 569 << now_uni; 570 571 #undef TEST_CONVERSION_ROUND_TRIP 572 } 573 574 template <typename Duration> 575 std::chrono::system_clock::time_point MakeChronoUnixTime(const Duration& d) { 576 return std::chrono::system_clock::from_time_t(0) + d; 577 } 578 579 TEST(Time, FromChrono) { 580 EXPECT_EQ(absl::FromTimeT(-1), 581 absl::FromChrono(std::chrono::system_clock::from_time_t(-1))); 582 EXPECT_EQ(absl::FromTimeT(0), 583 absl::FromChrono(std::chrono::system_clock::from_time_t(0))); 584 EXPECT_EQ(absl::FromTimeT(1), 585 absl::FromChrono(std::chrono::system_clock::from_time_t(1))); 586 587 EXPECT_EQ( 588 absl::FromUnixMillis(-1), 589 absl::FromChrono(MakeChronoUnixTime(std::chrono::milliseconds(-1)))); 590 EXPECT_EQ(absl::FromUnixMillis(0), 591 absl::FromChrono(MakeChronoUnixTime(std::chrono::milliseconds(0)))); 592 EXPECT_EQ(absl::FromUnixMillis(1), 593 absl::FromChrono(MakeChronoUnixTime(std::chrono::milliseconds(1)))); 594 595 // Chrono doesn't define exactly its range and precision (neither does 596 // absl::Time), so let's simply test +/- ~100 years to make sure things work. 597 const auto century_sec = 60 * 60 * 24 * 365 * int64_t{100}; 598 const auto century = std::chrono::seconds(century_sec); 599 const auto chrono_future = MakeChronoUnixTime(century); 600 const auto chrono_past = MakeChronoUnixTime(-century); 601 EXPECT_EQ(absl::FromUnixSeconds(century_sec), 602 absl::FromChrono(chrono_future)); 603 EXPECT_EQ(absl::FromUnixSeconds(-century_sec), absl::FromChrono(chrono_past)); 604 605 // Roundtrip them both back to chrono. 606 EXPECT_EQ(chrono_future, 607 absl::ToChronoTime(absl::FromUnixSeconds(century_sec))); 608 EXPECT_EQ(chrono_past, 609 absl::ToChronoTime(absl::FromUnixSeconds(-century_sec))); 610 } 611 612 TEST(Time, ToChronoTime) { 613 EXPECT_EQ(std::chrono::system_clock::from_time_t(-1), 614 absl::ToChronoTime(absl::FromTimeT(-1))); 615 EXPECT_EQ(std::chrono::system_clock::from_time_t(0), 616 absl::ToChronoTime(absl::FromTimeT(0))); 617 EXPECT_EQ(std::chrono::system_clock::from_time_t(1), 618 absl::ToChronoTime(absl::FromTimeT(1))); 619 620 EXPECT_EQ(MakeChronoUnixTime(std::chrono::milliseconds(-1)), 621 absl::ToChronoTime(absl::FromUnixMillis(-1))); 622 EXPECT_EQ(MakeChronoUnixTime(std::chrono::milliseconds(0)), 623 absl::ToChronoTime(absl::FromUnixMillis(0))); 624 EXPECT_EQ(MakeChronoUnixTime(std::chrono::milliseconds(1)), 625 absl::ToChronoTime(absl::FromUnixMillis(1))); 626 627 // Time before the Unix epoch should floor, not trunc. 628 const auto tick = absl::Nanoseconds(1) / 4; 629 EXPECT_EQ(std::chrono::system_clock::from_time_t(0) - 630 std::chrono::system_clock::duration(1), 631 absl::ToChronoTime(absl::UnixEpoch() - tick)); 632 } 633 634 // Check that absl::int128 works as a std::chrono::duration representation. 635 TEST(Time, Chrono128) { 636 // Define a std::chrono::time_point type whose time[sic]_since_epoch() is 637 // a signed 128-bit count of attoseconds. This has a range and resolution 638 // (currently) beyond those of absl::Time, and undoubtedly also beyond those 639 // of std::chrono::system_clock::time_point. 640 // 641 // Note: The to/from-chrono support should probably be updated to handle 642 // such wide representations. 643 using Timestamp = 644 std::chrono::time_point<std::chrono::system_clock, 645 std::chrono::duration<absl::int128, std::atto>>; 646 647 // Expect that we can round-trip the std::chrono::system_clock::time_point 648 // extremes through both absl::Time and Timestamp, and that Timestamp can 649 // handle the (current) absl::Time extremes. 650 // 651 // Note: We should use std::chrono::floor() instead of time_point_cast(), 652 // but floor() is only available since c++17. 653 for (const auto tp : {std::chrono::system_clock::time_point::min(), 654 std::chrono::system_clock::time_point::max()}) { 655 EXPECT_EQ(tp, absl::ToChronoTime(absl::FromChrono(tp))); 656 EXPECT_EQ(tp, std::chrono::time_point_cast< 657 std::chrono::system_clock::time_point::duration>( 658 std::chrono::time_point_cast<Timestamp::duration>(tp))); 659 } 660 Timestamp::duration::rep v = std::numeric_limits<int64_t>::min(); 661 v *= Timestamp::duration::period::den; 662 auto ts = Timestamp(Timestamp::duration(v)); 663 ts += std::chrono::duration<int64_t, std::atto>(0); 664 EXPECT_EQ(std::numeric_limits<int64_t>::min(), 665 ts.time_since_epoch().count() / Timestamp::duration::period::den); 666 EXPECT_EQ(0, 667 ts.time_since_epoch().count() % Timestamp::duration::period::den); 668 v = std::numeric_limits<int64_t>::max(); 669 v *= Timestamp::duration::period::den; 670 ts = Timestamp(Timestamp::duration(v)); 671 ts += std::chrono::duration<int64_t, std::atto>(999999999750000000); 672 EXPECT_EQ(std::numeric_limits<int64_t>::max(), 673 ts.time_since_epoch().count() / Timestamp::duration::period::den); 674 EXPECT_EQ(999999999750000000, 675 ts.time_since_epoch().count() % Timestamp::duration::period::den); 676 } 677 678 TEST(Time, TimeZoneAt) { 679 const absl::TimeZone nyc = 680 absl::time_internal::LoadTimeZone("America/New_York"); 681 const std::string fmt = "%a, %e %b %Y %H:%M:%S %z (%Z)"; 682 683 // A non-transition where the civil time is unique. 684 absl::CivilSecond nov01(2013, 11, 1, 8, 30, 0); 685 const auto nov01_ci = nyc.At(nov01); 686 EXPECT_EQ(absl::TimeZone::TimeInfo::UNIQUE, nov01_ci.kind); 687 EXPECT_EQ("Fri, 1 Nov 2013 08:30:00 -0400 (EDT)", 688 absl::FormatTime(fmt, nov01_ci.pre, nyc)); 689 EXPECT_EQ(nov01_ci.pre, nov01_ci.trans); 690 EXPECT_EQ(nov01_ci.pre, nov01_ci.post); 691 EXPECT_EQ(nov01_ci.pre, absl::FromCivil(nov01, nyc)); 692 693 // A Spring DST transition, when there is a gap in civil time 694 // and we prefer the later of the possible interpretations of a 695 // non-existent time. 696 absl::CivilSecond mar13(2011, 3, 13, 2, 15, 0); 697 const auto mar_ci = nyc.At(mar13); 698 EXPECT_EQ(absl::TimeZone::TimeInfo::SKIPPED, mar_ci.kind); 699 EXPECT_EQ("Sun, 13 Mar 2011 03:15:00 -0400 (EDT)", 700 absl::FormatTime(fmt, mar_ci.pre, nyc)); 701 EXPECT_EQ("Sun, 13 Mar 2011 03:00:00 -0400 (EDT)", 702 absl::FormatTime(fmt, mar_ci.trans, nyc)); 703 EXPECT_EQ("Sun, 13 Mar 2011 01:15:00 -0500 (EST)", 704 absl::FormatTime(fmt, mar_ci.post, nyc)); 705 EXPECT_EQ(mar_ci.trans, absl::FromCivil(mar13, nyc)); 706 707 // A Fall DST transition, when civil times are repeated and 708 // we prefer the earlier of the possible interpretations of an 709 // ambiguous time. 710 absl::CivilSecond nov06(2011, 11, 6, 1, 15, 0); 711 const auto nov06_ci = nyc.At(nov06); 712 EXPECT_EQ(absl::TimeZone::TimeInfo::REPEATED, nov06_ci.kind); 713 EXPECT_EQ("Sun, 6 Nov 2011 01:15:00 -0400 (EDT)", 714 absl::FormatTime(fmt, nov06_ci.pre, nyc)); 715 EXPECT_EQ("Sun, 6 Nov 2011 01:00:00 -0500 (EST)", 716 absl::FormatTime(fmt, nov06_ci.trans, nyc)); 717 EXPECT_EQ("Sun, 6 Nov 2011 01:15:00 -0500 (EST)", 718 absl::FormatTime(fmt, nov06_ci.post, nyc)); 719 EXPECT_EQ(nov06_ci.pre, absl::FromCivil(nov06, nyc)); 720 721 // Check that (time_t) -1 is handled correctly. 722 absl::CivilSecond minus1(1969, 12, 31, 18, 59, 59); 723 const auto minus1_cl = nyc.At(minus1); 724 EXPECT_EQ(absl::TimeZone::TimeInfo::UNIQUE, minus1_cl.kind); 725 EXPECT_EQ(-1, absl::ToTimeT(minus1_cl.pre)); 726 EXPECT_EQ("Wed, 31 Dec 1969 18:59:59 -0500 (EST)", 727 absl::FormatTime(fmt, minus1_cl.pre, nyc)); 728 EXPECT_EQ("Wed, 31 Dec 1969 23:59:59 +0000 (UTC)", 729 absl::FormatTime(fmt, minus1_cl.pre, absl::UTCTimeZone())); 730 } 731 732 // FromCivil(CivilSecond(year, mon, day, hour, min, sec), UTCTimeZone()) 733 // has a specialized fastpath implementation, which we exercise here. 734 TEST(Time, FromCivilUTC) { 735 const absl::TimeZone utc = absl::UTCTimeZone(); 736 const std::string fmt = "%a, %e %b %Y %H:%M:%S %z (%Z)"; 737 const int kMax = std::numeric_limits<int>::max(); 738 const int kMin = std::numeric_limits<int>::min(); 739 absl::Time t; 740 741 // 292091940881 is the last positive year to use the fastpath. 742 t = absl::FromCivil( 743 absl::CivilSecond(292091940881, kMax, kMax, kMax, kMax, kMax), utc); 744 EXPECT_EQ("Fri, 25 Nov 292277026596 12:21:07 +0000 (UTC)", 745 absl::FormatTime(fmt, t, utc)); 746 t = absl::FromCivil( 747 absl::CivilSecond(292091940882, kMax, kMax, kMax, kMax, kMax), utc); 748 EXPECT_EQ("infinite-future", absl::FormatTime(fmt, t, utc)); // no overflow 749 750 // -292091936940 is the last negative year to use the fastpath. 751 t = absl::FromCivil( 752 absl::CivilSecond(-292091936940, kMin, kMin, kMin, kMin, kMin), utc); 753 EXPECT_EQ("Fri, 1 Nov -292277022657 10:37:52 +0000 (UTC)", 754 absl::FormatTime(fmt, t, utc)); 755 t = absl::FromCivil( 756 absl::CivilSecond(-292091936941, kMin, kMin, kMin, kMin, kMin), utc); 757 EXPECT_EQ("infinite-past", absl::FormatTime(fmt, t, utc)); // no underflow 758 759 // Check that we're counting leap years correctly. 760 t = absl::FromCivil(absl::CivilSecond(1900, 2, 28, 23, 59, 59), utc); 761 EXPECT_EQ("Wed, 28 Feb 1900 23:59:59 +0000 (UTC)", 762 absl::FormatTime(fmt, t, utc)); 763 t = absl::FromCivil(absl::CivilSecond(1900, 3, 1, 0, 0, 0), utc); 764 EXPECT_EQ("Thu, 1 Mar 1900 00:00:00 +0000 (UTC)", 765 absl::FormatTime(fmt, t, utc)); 766 t = absl::FromCivil(absl::CivilSecond(2000, 2, 29, 23, 59, 59), utc); 767 EXPECT_EQ("Tue, 29 Feb 2000 23:59:59 +0000 (UTC)", 768 absl::FormatTime(fmt, t, utc)); 769 t = absl::FromCivil(absl::CivilSecond(2000, 3, 1, 0, 0, 0), utc); 770 EXPECT_EQ("Wed, 1 Mar 2000 00:00:00 +0000 (UTC)", 771 absl::FormatTime(fmt, t, utc)); 772 } 773 774 TEST(Time, ToTM) { 775 const absl::TimeZone utc = absl::UTCTimeZone(); 776 777 // Compares the results of absl::ToTM() to gmtime_r() for lots of times over 778 // the course of a few days. 779 const absl::Time start = 780 absl::FromCivil(absl::CivilSecond(2014, 1, 2, 3, 4, 5), utc); 781 const absl::Time end = 782 absl::FromCivil(absl::CivilSecond(2014, 1, 5, 3, 4, 5), utc); 783 for (absl::Time t = start; t < end; t += absl::Seconds(30)) { 784 const struct tm tm_bt = absl::ToTM(t, utc); 785 const time_t tt = absl::ToTimeT(t); 786 struct tm tm_lc; 787 #ifdef _WIN32 788 gmtime_s(&tm_lc, &tt); 789 #else 790 gmtime_r(&tt, &tm_lc); 791 #endif 792 EXPECT_EQ(tm_lc.tm_year, tm_bt.tm_year); 793 EXPECT_EQ(tm_lc.tm_mon, tm_bt.tm_mon); 794 EXPECT_EQ(tm_lc.tm_mday, tm_bt.tm_mday); 795 EXPECT_EQ(tm_lc.tm_hour, tm_bt.tm_hour); 796 EXPECT_EQ(tm_lc.tm_min, tm_bt.tm_min); 797 EXPECT_EQ(tm_lc.tm_sec, tm_bt.tm_sec); 798 EXPECT_EQ(tm_lc.tm_wday, tm_bt.tm_wday); 799 EXPECT_EQ(tm_lc.tm_yday, tm_bt.tm_yday); 800 EXPECT_EQ(tm_lc.tm_isdst, tm_bt.tm_isdst); 801 802 ASSERT_FALSE(HasFailure()); 803 } 804 805 // Checks that the tm_isdst field is correct when in standard time. 806 const absl::TimeZone nyc = 807 absl::time_internal::LoadTimeZone("America/New_York"); 808 absl::Time t = absl::FromCivil(absl::CivilSecond(2014, 3, 1, 0, 0, 0), nyc); 809 struct tm tm = absl::ToTM(t, nyc); 810 EXPECT_FALSE(tm.tm_isdst); 811 812 // Checks that the tm_isdst field is correct when in daylight time. 813 t = absl::FromCivil(absl::CivilSecond(2014, 4, 1, 0, 0, 0), nyc); 814 tm = absl::ToTM(t, nyc); 815 EXPECT_TRUE(tm.tm_isdst); 816 817 // Checks overflow. 818 tm = absl::ToTM(absl::InfiniteFuture(), nyc); 819 EXPECT_EQ(std::numeric_limits<int>::max() - 1900, tm.tm_year); 820 EXPECT_EQ(11, tm.tm_mon); 821 EXPECT_EQ(31, tm.tm_mday); 822 EXPECT_EQ(23, tm.tm_hour); 823 EXPECT_EQ(59, tm.tm_min); 824 EXPECT_EQ(59, tm.tm_sec); 825 EXPECT_EQ(4, tm.tm_wday); 826 EXPECT_EQ(364, tm.tm_yday); 827 EXPECT_FALSE(tm.tm_isdst); 828 829 // Checks underflow. 830 tm = absl::ToTM(absl::InfinitePast(), nyc); 831 EXPECT_EQ(std::numeric_limits<int>::min(), tm.tm_year); 832 EXPECT_EQ(0, tm.tm_mon); 833 EXPECT_EQ(1, tm.tm_mday); 834 EXPECT_EQ(0, tm.tm_hour); 835 EXPECT_EQ(0, tm.tm_min); 836 EXPECT_EQ(0, tm.tm_sec); 837 EXPECT_EQ(0, tm.tm_wday); 838 EXPECT_EQ(0, tm.tm_yday); 839 EXPECT_FALSE(tm.tm_isdst); 840 } 841 842 TEST(Time, FromTM) { 843 const absl::TimeZone nyc = 844 absl::time_internal::LoadTimeZone("America/New_York"); 845 846 // Verifies that tm_isdst doesn't affect anything when the time is unique. 847 struct tm tm; 848 std::memset(&tm, 0, sizeof(tm)); 849 tm.tm_year = 2014 - 1900; 850 tm.tm_mon = 6 - 1; 851 tm.tm_mday = 28; 852 tm.tm_hour = 1; 853 tm.tm_min = 2; 854 tm.tm_sec = 3; 855 tm.tm_isdst = -1; 856 absl::Time t = absl::FromTM(tm, nyc); 857 EXPECT_EQ("2014-06-28T01:02:03-04:00", absl::FormatTime(t, nyc)); // DST 858 tm.tm_isdst = 0; 859 t = absl::FromTM(tm, nyc); 860 EXPECT_EQ("2014-06-28T01:02:03-04:00", absl::FormatTime(t, nyc)); // DST 861 tm.tm_isdst = 1; 862 t = absl::FromTM(tm, nyc); 863 EXPECT_EQ("2014-06-28T01:02:03-04:00", absl::FormatTime(t, nyc)); // DST 864 865 // Adjusts tm to refer to an ambiguous time. 866 tm.tm_year = 2014 - 1900; 867 tm.tm_mon = 11 - 1; 868 tm.tm_mday = 2; 869 tm.tm_hour = 1; 870 tm.tm_min = 30; 871 tm.tm_sec = 42; 872 tm.tm_isdst = -1; 873 t = absl::FromTM(tm, nyc); 874 EXPECT_EQ("2014-11-02T01:30:42-04:00", absl::FormatTime(t, nyc)); // DST 875 tm.tm_isdst = 0; 876 t = absl::FromTM(tm, nyc); 877 EXPECT_EQ("2014-11-02T01:30:42-05:00", absl::FormatTime(t, nyc)); // STD 878 tm.tm_isdst = 1; 879 t = absl::FromTM(tm, nyc); 880 EXPECT_EQ("2014-11-02T01:30:42-04:00", absl::FormatTime(t, nyc)); // DST 881 882 // Adjusts tm to refer to a skipped time. 883 tm.tm_year = 2014 - 1900; 884 tm.tm_mon = 3 - 1; 885 tm.tm_mday = 9; 886 tm.tm_hour = 2; 887 tm.tm_min = 30; 888 tm.tm_sec = 42; 889 tm.tm_isdst = -1; 890 t = absl::FromTM(tm, nyc); 891 EXPECT_EQ("2014-03-09T03:30:42-04:00", absl::FormatTime(t, nyc)); // DST 892 tm.tm_isdst = 0; 893 t = absl::FromTM(tm, nyc); 894 EXPECT_EQ("2014-03-09T01:30:42-05:00", absl::FormatTime(t, nyc)); // STD 895 tm.tm_isdst = 1; 896 t = absl::FromTM(tm, nyc); 897 EXPECT_EQ("2014-03-09T03:30:42-04:00", absl::FormatTime(t, nyc)); // DST 898 899 // Adjusts tm to refer to a time with a year larger than 2147483647. 900 tm.tm_year = 2147483647 - 1900 + 1; 901 tm.tm_mon = 6 - 1; 902 tm.tm_mday = 28; 903 tm.tm_hour = 1; 904 tm.tm_min = 2; 905 tm.tm_sec = 3; 906 tm.tm_isdst = -1; 907 t = absl::FromTM(tm, absl::UTCTimeZone()); 908 EXPECT_EQ("2147483648-06-28T01:02:03+00:00", 909 absl::FormatTime(t, absl::UTCTimeZone())); 910 911 // Adjusts tm to refer to a time with a very large month. 912 tm.tm_year = 2019 - 1900; 913 tm.tm_mon = 2147483647; 914 tm.tm_mday = 28; 915 tm.tm_hour = 1; 916 tm.tm_min = 2; 917 tm.tm_sec = 3; 918 tm.tm_isdst = -1; 919 t = absl::FromTM(tm, absl::UTCTimeZone()); 920 EXPECT_EQ("178958989-08-28T01:02:03+00:00", 921 absl::FormatTime(t, absl::UTCTimeZone())); 922 } 923 924 TEST(Time, TMRoundTrip) { 925 const absl::TimeZone nyc = 926 absl::time_internal::LoadTimeZone("America/New_York"); 927 928 // Test round-tripping across a skipped transition 929 absl::Time start = absl::FromCivil(absl::CivilHour(2014, 3, 9, 0), nyc); 930 absl::Time end = absl::FromCivil(absl::CivilHour(2014, 3, 9, 4), nyc); 931 for (absl::Time t = start; t < end; t += absl::Minutes(1)) { 932 struct tm tm = absl::ToTM(t, nyc); 933 absl::Time rt = absl::FromTM(tm, nyc); 934 EXPECT_EQ(rt, t); 935 } 936 937 // Test round-tripping across an ambiguous transition 938 start = absl::FromCivil(absl::CivilHour(2014, 11, 2, 0), nyc); 939 end = absl::FromCivil(absl::CivilHour(2014, 11, 2, 4), nyc); 940 for (absl::Time t = start; t < end; t += absl::Minutes(1)) { 941 struct tm tm = absl::ToTM(t, nyc); 942 absl::Time rt = absl::FromTM(tm, nyc); 943 EXPECT_EQ(rt, t); 944 } 945 946 // Test round-tripping of unique instants crossing a day boundary 947 start = absl::FromCivil(absl::CivilHour(2014, 6, 27, 22), nyc); 948 end = absl::FromCivil(absl::CivilHour(2014, 6, 28, 4), nyc); 949 for (absl::Time t = start; t < end; t += absl::Minutes(1)) { 950 struct tm tm = absl::ToTM(t, nyc); 951 absl::Time rt = absl::FromTM(tm, nyc); 952 EXPECT_EQ(rt, t); 953 } 954 } 955 956 TEST(Time, Range) { 957 // The API's documented range is +/- 100 billion years. 958 const absl::Duration range = absl::Hours(24) * 365.2425 * 100000000000; 959 960 // Arithmetic and comparison still works at +/-range around base values. 961 absl::Time bases[2] = {absl::UnixEpoch(), absl::Now()}; 962 for (const auto base : bases) { 963 absl::Time bottom = base - range; 964 EXPECT_GT(bottom, bottom - absl::Nanoseconds(1)); 965 EXPECT_LT(bottom, bottom + absl::Nanoseconds(1)); 966 absl::Time top = base + range; 967 EXPECT_GT(top, top - absl::Nanoseconds(1)); 968 EXPECT_LT(top, top + absl::Nanoseconds(1)); 969 absl::Duration full_range = 2 * range; 970 EXPECT_EQ(full_range, top - bottom); 971 EXPECT_EQ(-full_range, bottom - top); 972 } 973 } 974 975 TEST(Time, Limits) { 976 // It is an implementation detail that Time().rep_ == ZeroDuration(), 977 // and that the resolution of a Duration is 1/4 of a nanosecond. 978 const absl::Time zero; 979 const absl::Time max = 980 zero + absl::Seconds(std::numeric_limits<int64_t>::max()) + 981 absl::Nanoseconds(999999999) + absl::Nanoseconds(3) / 4; 982 const absl::Time min = 983 zero + absl::Seconds(std::numeric_limits<int64_t>::min()); 984 985 // Some simple max/min bounds checks. 986 EXPECT_LT(max, absl::InfiniteFuture()); 987 EXPECT_GT(min, absl::InfinitePast()); 988 EXPECT_LT(zero, max); 989 EXPECT_GT(zero, min); 990 EXPECT_GE(absl::UnixEpoch(), min); 991 EXPECT_LT(absl::UnixEpoch(), max); 992 993 // Check sign of Time differences. 994 EXPECT_LT(absl::ZeroDuration(), max - zero); 995 EXPECT_LT(absl::ZeroDuration(), 996 zero - absl::Nanoseconds(1) / 4 - min); // avoid zero - min 997 998 // Arithmetic works at max - 0.25ns and min + 0.25ns. 999 EXPECT_GT(max, max - absl::Nanoseconds(1) / 4); 1000 EXPECT_LT(min, min + absl::Nanoseconds(1) / 4); 1001 } 1002 1003 TEST(Time, ConversionSaturation) { 1004 const absl::TimeZone utc = absl::UTCTimeZone(); 1005 absl::Time t; 1006 1007 const auto max_time_t = std::numeric_limits<time_t>::max(); 1008 const auto min_time_t = std::numeric_limits<time_t>::min(); 1009 time_t tt = max_time_t - 1; 1010 t = absl::FromTimeT(tt); 1011 tt = absl::ToTimeT(t); 1012 EXPECT_EQ(max_time_t - 1, tt); 1013 t += absl::Seconds(1); 1014 tt = absl::ToTimeT(t); 1015 EXPECT_EQ(max_time_t, tt); 1016 t += absl::Seconds(1); // no effect 1017 tt = absl::ToTimeT(t); 1018 EXPECT_EQ(max_time_t, tt); 1019 1020 tt = min_time_t + 1; 1021 t = absl::FromTimeT(tt); 1022 tt = absl::ToTimeT(t); 1023 EXPECT_EQ(min_time_t + 1, tt); 1024 t -= absl::Seconds(1); 1025 tt = absl::ToTimeT(t); 1026 EXPECT_EQ(min_time_t, tt); 1027 t -= absl::Seconds(1); // no effect 1028 tt = absl::ToTimeT(t); 1029 EXPECT_EQ(min_time_t, tt); 1030 1031 const auto max_timeval_sec = 1032 std::numeric_limits<decltype(timeval::tv_sec)>::max(); 1033 const auto min_timeval_sec = 1034 std::numeric_limits<decltype(timeval::tv_sec)>::min(); 1035 timeval tv; 1036 tv.tv_sec = max_timeval_sec; 1037 tv.tv_usec = 999998; 1038 t = absl::TimeFromTimeval(tv); 1039 tv = absl::ToTimeval(t); 1040 EXPECT_EQ(max_timeval_sec, tv.tv_sec); 1041 EXPECT_EQ(999998, tv.tv_usec); 1042 t += absl::Microseconds(1); 1043 tv = absl::ToTimeval(t); 1044 EXPECT_EQ(max_timeval_sec, tv.tv_sec); 1045 EXPECT_EQ(999999, tv.tv_usec); 1046 t += absl::Microseconds(1); // no effect 1047 tv = absl::ToTimeval(t); 1048 EXPECT_EQ(max_timeval_sec, tv.tv_sec); 1049 EXPECT_EQ(999999, tv.tv_usec); 1050 1051 tv.tv_sec = min_timeval_sec; 1052 tv.tv_usec = 1; 1053 t = absl::TimeFromTimeval(tv); 1054 tv = absl::ToTimeval(t); 1055 EXPECT_EQ(min_timeval_sec, tv.tv_sec); 1056 EXPECT_EQ(1, tv.tv_usec); 1057 t -= absl::Microseconds(1); 1058 tv = absl::ToTimeval(t); 1059 EXPECT_EQ(min_timeval_sec, tv.tv_sec); 1060 EXPECT_EQ(0, tv.tv_usec); 1061 t -= absl::Microseconds(1); // no effect 1062 tv = absl::ToTimeval(t); 1063 EXPECT_EQ(min_timeval_sec, tv.tv_sec); 1064 EXPECT_EQ(0, tv.tv_usec); 1065 1066 const auto max_timespec_sec = 1067 std::numeric_limits<decltype(timespec::tv_sec)>::max(); 1068 const auto min_timespec_sec = 1069 std::numeric_limits<decltype(timespec::tv_sec)>::min(); 1070 timespec ts; 1071 ts.tv_sec = max_timespec_sec; 1072 ts.tv_nsec = 999999998; 1073 t = absl::TimeFromTimespec(ts); 1074 ts = absl::ToTimespec(t); 1075 EXPECT_EQ(max_timespec_sec, ts.tv_sec); 1076 EXPECT_EQ(999999998, ts.tv_nsec); 1077 t += absl::Nanoseconds(1); 1078 ts = absl::ToTimespec(t); 1079 EXPECT_EQ(max_timespec_sec, ts.tv_sec); 1080 EXPECT_EQ(999999999, ts.tv_nsec); 1081 t += absl::Nanoseconds(1); // no effect 1082 ts = absl::ToTimespec(t); 1083 EXPECT_EQ(max_timespec_sec, ts.tv_sec); 1084 EXPECT_EQ(999999999, ts.tv_nsec); 1085 1086 ts.tv_sec = min_timespec_sec; 1087 ts.tv_nsec = 1; 1088 t = absl::TimeFromTimespec(ts); 1089 ts = absl::ToTimespec(t); 1090 EXPECT_EQ(min_timespec_sec, ts.tv_sec); 1091 EXPECT_EQ(1, ts.tv_nsec); 1092 t -= absl::Nanoseconds(1); 1093 ts = absl::ToTimespec(t); 1094 EXPECT_EQ(min_timespec_sec, ts.tv_sec); 1095 EXPECT_EQ(0, ts.tv_nsec); 1096 t -= absl::Nanoseconds(1); // no effect 1097 ts = absl::ToTimespec(t); 1098 EXPECT_EQ(min_timespec_sec, ts.tv_sec); 1099 EXPECT_EQ(0, ts.tv_nsec); 1100 1101 // Checks how TimeZone::At() saturates on infinities. 1102 auto ci = utc.At(absl::InfiniteFuture()); 1103 EXPECT_CIVIL_INFO(ci, std::numeric_limits<int64_t>::max(), 12, 31, 23, 59, 59, 1104 0, false); 1105 EXPECT_EQ(absl::InfiniteDuration(), ci.subsecond); 1106 EXPECT_EQ(absl::Weekday::thursday, absl::GetWeekday(ci.cs)); 1107 EXPECT_EQ(365, absl::GetYearDay(ci.cs)); 1108 EXPECT_STREQ("-00", ci.zone_abbr); // artifact of TimeZone::At() 1109 ci = utc.At(absl::InfinitePast()); 1110 EXPECT_CIVIL_INFO(ci, std::numeric_limits<int64_t>::min(), 1, 1, 0, 0, 0, 0, 1111 false); 1112 EXPECT_EQ(-absl::InfiniteDuration(), ci.subsecond); 1113 EXPECT_EQ(absl::Weekday::sunday, absl::GetWeekday(ci.cs)); 1114 EXPECT_EQ(1, absl::GetYearDay(ci.cs)); 1115 EXPECT_STREQ("-00", ci.zone_abbr); // artifact of TimeZone::At() 1116 1117 // Approach the maximal Time value from below. 1118 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 4, 15, 30, 6), utc); 1119 EXPECT_EQ("292277026596-12-04T15:30:06+00:00", 1120 absl::FormatTime(absl::RFC3339_full, t, utc)); 1121 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 4, 15, 30, 7), utc); 1122 EXPECT_EQ("292277026596-12-04T15:30:07+00:00", 1123 absl::FormatTime(absl::RFC3339_full, t, utc)); 1124 EXPECT_EQ( 1125 absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::max()), 1126 t); 1127 1128 // Checks that we can also get the maximal Time value for a far-east zone. 1129 const absl::TimeZone plus14 = absl::FixedTimeZone(14 * 60 * 60); 1130 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 5, 5, 30, 7), plus14); 1131 EXPECT_EQ("292277026596-12-05T05:30:07+14:00", 1132 absl::FormatTime(absl::RFC3339_full, t, plus14)); 1133 EXPECT_EQ( 1134 absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::max()), 1135 t); 1136 1137 // One second later should push us to infinity. 1138 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 4, 15, 30, 8), utc); 1139 EXPECT_EQ("infinite-future", absl::FormatTime(absl::RFC3339_full, t, utc)); 1140 1141 // Approach the minimal Time value from above. 1142 t = absl::FromCivil(absl::CivilSecond(-292277022657, 1, 27, 8, 29, 53), utc); 1143 EXPECT_EQ("-292277022657-01-27T08:29:53+00:00", 1144 absl::FormatTime(absl::RFC3339_full, t, utc)); 1145 t = absl::FromCivil(absl::CivilSecond(-292277022657, 1, 27, 8, 29, 52), utc); 1146 EXPECT_EQ("-292277022657-01-27T08:29:52+00:00", 1147 absl::FormatTime(absl::RFC3339_full, t, utc)); 1148 EXPECT_EQ( 1149 absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::min()), 1150 t); 1151 1152 // Checks that we can also get the minimal Time value for a far-west zone. 1153 const absl::TimeZone minus12 = absl::FixedTimeZone(-12 * 60 * 60); 1154 t = absl::FromCivil(absl::CivilSecond(-292277022657, 1, 26, 20, 29, 52), 1155 minus12); 1156 EXPECT_EQ("-292277022657-01-26T20:29:52-12:00", 1157 absl::FormatTime(absl::RFC3339_full, t, minus12)); 1158 EXPECT_EQ( 1159 absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::min()), 1160 t); 1161 1162 // One second before should push us to -infinity. 1163 t = absl::FromCivil(absl::CivilSecond(-292277022657, 1, 27, 8, 29, 51), utc); 1164 EXPECT_EQ("infinite-past", absl::FormatTime(absl::RFC3339_full, t, utc)); 1165 } 1166 1167 // In zones with POSIX-style recurring rules we use special logic to 1168 // handle conversions in the distant future. Here we check the limits 1169 // of those conversions, particularly with respect to integer overflow. 1170 TEST(Time, ExtendedConversionSaturation) { 1171 const absl::TimeZone syd = 1172 absl::time_internal::LoadTimeZone("Australia/Sydney"); 1173 const absl::TimeZone nyc = 1174 absl::time_internal::LoadTimeZone("America/New_York"); 1175 const absl::Time max = 1176 absl::FromUnixSeconds(std::numeric_limits<int64_t>::max()); 1177 absl::TimeZone::CivilInfo ci; 1178 absl::Time t; 1179 1180 // The maximal time converted in each zone. 1181 ci = syd.At(max); 1182 EXPECT_CIVIL_INFO(ci, 292277026596, 12, 5, 2, 30, 7, 39600, true); 1183 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 5, 2, 30, 7), syd); 1184 EXPECT_EQ(max, t); 1185 ci = nyc.At(max); 1186 EXPECT_CIVIL_INFO(ci, 292277026596, 12, 4, 10, 30, 7, -18000, false); 1187 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 4, 10, 30, 7), nyc); 1188 EXPECT_EQ(max, t); 1189 1190 // One second later should push us to infinity. 1191 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 5, 2, 30, 8), syd); 1192 EXPECT_EQ(absl::InfiniteFuture(), t); 1193 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 4, 10, 30, 8), nyc); 1194 EXPECT_EQ(absl::InfiniteFuture(), t); 1195 1196 // And we should stick there. 1197 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 5, 2, 30, 9), syd); 1198 EXPECT_EQ(absl::InfiniteFuture(), t); 1199 t = absl::FromCivil(absl::CivilSecond(292277026596, 12, 4, 10, 30, 9), nyc); 1200 EXPECT_EQ(absl::InfiniteFuture(), t); 1201 1202 // All the way up to a saturated date/time, without overflow. 1203 t = absl::FromCivil(absl::CivilSecond::max(), syd); 1204 EXPECT_EQ(absl::InfiniteFuture(), t); 1205 t = absl::FromCivil(absl::CivilSecond::max(), nyc); 1206 EXPECT_EQ(absl::InfiniteFuture(), t); 1207 } 1208 1209 TEST(Time, FromCivilAlignment) { 1210 const absl::TimeZone utc = absl::UTCTimeZone(); 1211 const absl::CivilSecond cs(2015, 2, 3, 4, 5, 6); 1212 absl::Time t = absl::FromCivil(cs, utc); 1213 EXPECT_EQ("2015-02-03T04:05:06+00:00", absl::FormatTime(t, utc)); 1214 t = absl::FromCivil(absl::CivilMinute(cs), utc); 1215 EXPECT_EQ("2015-02-03T04:05:00+00:00", absl::FormatTime(t, utc)); 1216 t = absl::FromCivil(absl::CivilHour(cs), utc); 1217 EXPECT_EQ("2015-02-03T04:00:00+00:00", absl::FormatTime(t, utc)); 1218 t = absl::FromCivil(absl::CivilDay(cs), utc); 1219 EXPECT_EQ("2015-02-03T00:00:00+00:00", absl::FormatTime(t, utc)); 1220 t = absl::FromCivil(absl::CivilMonth(cs), utc); 1221 EXPECT_EQ("2015-02-01T00:00:00+00:00", absl::FormatTime(t, utc)); 1222 t = absl::FromCivil(absl::CivilYear(cs), utc); 1223 EXPECT_EQ("2015-01-01T00:00:00+00:00", absl::FormatTime(t, utc)); 1224 } 1225 1226 TEST(Time, LegacyDateTime) { 1227 const absl::TimeZone utc = absl::UTCTimeZone(); 1228 const std::string ymdhms = "%Y-%m-%d %H:%M:%S"; 1229 const int kMax = std::numeric_limits<int>::max(); 1230 const int kMin = std::numeric_limits<int>::min(); 1231 absl::Time t; 1232 1233 t = absl::FromDateTime(std::numeric_limits<absl::civil_year_t>::max(), kMax, 1234 kMax, kMax, kMax, kMax, utc); 1235 EXPECT_EQ("infinite-future", 1236 absl::FormatTime(ymdhms, t, utc)); // no overflow 1237 t = absl::FromDateTime(std::numeric_limits<absl::civil_year_t>::min(), kMin, 1238 kMin, kMin, kMin, kMin, utc); 1239 EXPECT_EQ("infinite-past", absl::FormatTime(ymdhms, t, utc)); // no overflow 1240 1241 // Check normalization. 1242 EXPECT_TRUE(absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, utc).normalized); 1243 t = absl::FromDateTime(2015, 1, 1, 0, 0, 60, utc); 1244 EXPECT_EQ("2015-01-01 00:01:00", absl::FormatTime(ymdhms, t, utc)); 1245 t = absl::FromDateTime(2015, 1, 1, 0, 60, 0, utc); 1246 EXPECT_EQ("2015-01-01 01:00:00", absl::FormatTime(ymdhms, t, utc)); 1247 t = absl::FromDateTime(2015, 1, 1, 24, 0, 0, utc); 1248 EXPECT_EQ("2015-01-02 00:00:00", absl::FormatTime(ymdhms, t, utc)); 1249 t = absl::FromDateTime(2015, 1, 32, 0, 0, 0, utc); 1250 EXPECT_EQ("2015-02-01 00:00:00", absl::FormatTime(ymdhms, t, utc)); 1251 t = absl::FromDateTime(2015, 13, 1, 0, 0, 0, utc); 1252 EXPECT_EQ("2016-01-01 00:00:00", absl::FormatTime(ymdhms, t, utc)); 1253 t = absl::FromDateTime(2015, 13, 32, 60, 60, 60, utc); 1254 EXPECT_EQ("2016-02-03 13:01:00", absl::FormatTime(ymdhms, t, utc)); 1255 t = absl::FromDateTime(2015, 1, 1, 0, 0, -1, utc); 1256 EXPECT_EQ("2014-12-31 23:59:59", absl::FormatTime(ymdhms, t, utc)); 1257 t = absl::FromDateTime(2015, 1, 1, 0, -1, 0, utc); 1258 EXPECT_EQ("2014-12-31 23:59:00", absl::FormatTime(ymdhms, t, utc)); 1259 t = absl::FromDateTime(2015, 1, 1, -1, 0, 0, utc); 1260 EXPECT_EQ("2014-12-31 23:00:00", absl::FormatTime(ymdhms, t, utc)); 1261 t = absl::FromDateTime(2015, 1, -1, 0, 0, 0, utc); 1262 EXPECT_EQ("2014-12-30 00:00:00", absl::FormatTime(ymdhms, t, utc)); 1263 t = absl::FromDateTime(2015, -1, 1, 0, 0, 0, utc); 1264 EXPECT_EQ("2014-11-01 00:00:00", absl::FormatTime(ymdhms, t, utc)); 1265 t = absl::FromDateTime(2015, -1, -1, -1, -1, -1, utc); 1266 EXPECT_EQ("2014-10-29 22:58:59", absl::FormatTime(ymdhms, t, utc)); 1267 } 1268 1269 TEST(Time, NextTransitionUTC) { 1270 const auto tz = absl::UTCTimeZone(); 1271 absl::TimeZone::CivilTransition trans; 1272 1273 auto t = absl::InfinitePast(); 1274 EXPECT_FALSE(tz.NextTransition(t, &trans)); 1275 1276 t = absl::InfiniteFuture(); 1277 EXPECT_FALSE(tz.NextTransition(t, &trans)); 1278 } 1279 1280 TEST(Time, PrevTransitionUTC) { 1281 const auto tz = absl::UTCTimeZone(); 1282 absl::TimeZone::CivilTransition trans; 1283 1284 auto t = absl::InfiniteFuture(); 1285 EXPECT_FALSE(tz.PrevTransition(t, &trans)); 1286 1287 t = absl::InfinitePast(); 1288 EXPECT_FALSE(tz.PrevTransition(t, &trans)); 1289 } 1290 1291 TEST(Time, NextTransitionNYC) { 1292 const auto tz = absl::time_internal::LoadTimeZone("America/New_York"); 1293 absl::TimeZone::CivilTransition trans; 1294 1295 auto t = absl::FromCivil(absl::CivilSecond(2018, 6, 30, 0, 0, 0), tz); 1296 EXPECT_TRUE(tz.NextTransition(t, &trans)); 1297 EXPECT_EQ(absl::CivilSecond(2018, 11, 4, 2, 0, 0), trans.from); 1298 EXPECT_EQ(absl::CivilSecond(2018, 11, 4, 1, 0, 0), trans.to); 1299 1300 t = absl::InfiniteFuture(); 1301 EXPECT_FALSE(tz.NextTransition(t, &trans)); 1302 1303 t = absl::InfinitePast(); 1304 EXPECT_TRUE(tz.NextTransition(t, &trans)); 1305 if (trans.from == absl::CivilSecond(1918, 03, 31, 2, 0, 0)) { 1306 // It looks like the tzdata is only 32 bit (probably macOS), 1307 // which bottoms out at 1901-12-13T20:45:52+00:00. 1308 EXPECT_EQ(absl::CivilSecond(1918, 3, 31, 3, 0, 0), trans.to); 1309 } else { 1310 EXPECT_EQ(absl::CivilSecond(1883, 11, 18, 12, 3, 58), trans.from); 1311 EXPECT_EQ(absl::CivilSecond(1883, 11, 18, 12, 0, 0), trans.to); 1312 } 1313 } 1314 1315 TEST(Time, PrevTransitionNYC) { 1316 const auto tz = absl::time_internal::LoadTimeZone("America/New_York"); 1317 absl::TimeZone::CivilTransition trans; 1318 1319 auto t = absl::FromCivil(absl::CivilSecond(2018, 6, 30, 0, 0, 0), tz); 1320 EXPECT_TRUE(tz.PrevTransition(t, &trans)); 1321 EXPECT_EQ(absl::CivilSecond(2018, 3, 11, 2, 0, 0), trans.from); 1322 EXPECT_EQ(absl::CivilSecond(2018, 3, 11, 3, 0, 0), trans.to); 1323 1324 t = absl::InfinitePast(); 1325 EXPECT_FALSE(tz.PrevTransition(t, &trans)); 1326 1327 t = absl::InfiniteFuture(); 1328 EXPECT_TRUE(tz.PrevTransition(t, &trans)); 1329 // We have a transition but we don't know which one. 1330 } 1331 1332 TEST(Time, AbslStringify) { 1333 // FormatTime is already well tested, so just use one test case here to 1334 // verify that StrFormat("%v", t) works as expected. 1335 absl::Time t = absl::Now(); 1336 EXPECT_EQ(absl::StrFormat("%v", t), absl::FormatTime(t)); 1337 } 1338 1339 TEST(Time, SupportsHash) { 1340 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1341 absl::UTCTimeZone(), 1342 absl::FixedTimeZone(-8 * 60 * 60), 1343 absl::UTCTimeZone(), 1344 })); 1345 1346 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1347 absl::Now(), 1348 absl::UnixEpoch(), 1349 absl::UnixEpoch() + absl::Seconds(60), 1350 absl::UnixEpoch() + absl::Minutes(1), 1351 absl::InfiniteFuture(), 1352 absl::InfinitePast(), 1353 })); 1354 1355 EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ 1356 absl::Seconds(1), 1357 absl::Seconds(60), 1358 absl::Minutes(1), 1359 absl::InfiniteDuration(), 1360 -absl::InfiniteDuration(), 1361 })); 1362 } 1363 1364 } // namespace