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