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