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