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 #if defined(_MSC_VER)
16 #include <winsock2.h> // for timeval
17 #endif
18
19 #include "absl/base/config.h"
20
21 // For feature testing and determining which headers can be included.
22 #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
23 #include <version>
24 #endif
25
26 #include <array>
27 #include <cfloat>
28 #include <chrono> // NOLINT(build/c++11)
29 #ifdef __cpp_lib_three_way_comparison
30 #include <compare>
31 #endif // __cpp_lib_three_way_comparison
32 #include <cmath>
33 #include <cstdint>
34 #include <ctime>
35 #include <iomanip>
36 #include <limits>
37 #include <random>
38 #include <string>
39
40 #include "gmock/gmock.h"
41 #include "gtest/gtest.h"
42 #include "absl/strings/str_format.h"
43 #include "absl/time/time.h"
44
45 namespace {
46
47 constexpr int64_t kint64max = std::numeric_limits<int64_t>::max();
48 constexpr int64_t kint64min = std::numeric_limits<int64_t>::min();
49
50 // Approximates the given number of years. This is only used to make some test
51 // code more readable.
ApproxYears(int64_t n)52 absl::Duration ApproxYears(int64_t n) { return absl::Hours(n) * 365 * 24; }
53
54 // A gMock matcher to match timespec values. Use this matcher like:
55 // timespec ts1, ts2;
56 // EXPECT_THAT(ts1, TimespecMatcher(ts2));
57 MATCHER_P(TimespecMatcher, ts, "") {
58 if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec)
59 return true;
60 *result_listener << "expected: {" << ts.tv_sec << ", " << ts.tv_nsec << "} ";
61 *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_nsec << "}";
62 return false;
63 }
64
65 // A gMock matcher to match timeval values. Use this matcher like:
66 // timeval tv1, tv2;
67 // EXPECT_THAT(tv1, TimevalMatcher(tv2));
68 MATCHER_P(TimevalMatcher, tv, "") {
69 if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec)
70 return true;
71 *result_listener << "expected: {" << tv.tv_sec << ", " << tv.tv_usec << "} ";
72 *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_usec << "}";
73 return false;
74 }
75
TEST(Duration,ConstExpr)76 TEST(Duration, ConstExpr) {
77 constexpr absl::Duration d0 = absl::ZeroDuration();
78 static_assert(d0 == absl::ZeroDuration(), "ZeroDuration()");
79 constexpr absl::Duration d1 = absl::Seconds(1);
80 static_assert(d1 == absl::Seconds(1), "Seconds(1)");
81 static_assert(d1 != absl::ZeroDuration(), "Seconds(1)");
82 constexpr absl::Duration d2 = absl::InfiniteDuration();
83 static_assert(d2 == absl::InfiniteDuration(), "InfiniteDuration()");
84 static_assert(d2 != absl::ZeroDuration(), "InfiniteDuration()");
85 }
86
TEST(Duration,ValueSemantics)87 TEST(Duration, ValueSemantics) {
88 // If this compiles, the test passes.
89 constexpr absl::Duration a; // Default construction
90 constexpr absl::Duration b = a; // Copy construction
91 constexpr absl::Duration c(b); // Copy construction (again)
92
93 absl::Duration d;
94 d = c; // Assignment
95 }
96
TEST(Duration,Factories)97 TEST(Duration, Factories) {
98 constexpr absl::Duration zero = absl::ZeroDuration();
99 constexpr absl::Duration nano = absl::Nanoseconds(1);
100 constexpr absl::Duration micro = absl::Microseconds(1);
101 constexpr absl::Duration milli = absl::Milliseconds(1);
102 constexpr absl::Duration sec = absl::Seconds(1);
103 constexpr absl::Duration min = absl::Minutes(1);
104 constexpr absl::Duration hour = absl::Hours(1);
105
106 EXPECT_EQ(zero, absl::Duration());
107 EXPECT_EQ(zero, absl::Seconds(0));
108 EXPECT_EQ(nano, absl::Nanoseconds(1));
109 EXPECT_EQ(micro, absl::Nanoseconds(1000));
110 EXPECT_EQ(milli, absl::Microseconds(1000));
111 EXPECT_EQ(sec, absl::Milliseconds(1000));
112 EXPECT_EQ(min, absl::Seconds(60));
113 EXPECT_EQ(hour, absl::Minutes(60));
114
115 // Tests factory limits
116 const absl::Duration inf = absl::InfiniteDuration();
117
118 EXPECT_GT(inf, absl::Seconds(kint64max));
119 EXPECT_LT(-inf, absl::Seconds(kint64min));
120 EXPECT_LT(-inf, absl::Seconds(-kint64max));
121
122 EXPECT_EQ(inf, absl::Minutes(kint64max));
123 EXPECT_EQ(-inf, absl::Minutes(kint64min));
124 EXPECT_EQ(-inf, absl::Minutes(-kint64max));
125 EXPECT_GT(inf, absl::Minutes(kint64max / 60));
126 EXPECT_LT(-inf, absl::Minutes(kint64min / 60));
127 EXPECT_LT(-inf, absl::Minutes(-kint64max / 60));
128
129 EXPECT_EQ(inf, absl::Hours(kint64max));
130 EXPECT_EQ(-inf, absl::Hours(kint64min));
131 EXPECT_EQ(-inf, absl::Hours(-kint64max));
132 EXPECT_GT(inf, absl::Hours(kint64max / 3600));
133 EXPECT_LT(-inf, absl::Hours(kint64min / 3600));
134 EXPECT_LT(-inf, absl::Hours(-kint64max / 3600));
135 }
136
TEST(Duration,ToConversion)137 TEST(Duration, ToConversion) {
138 #define TEST_DURATION_CONVERSION(UNIT) \
139 do { \
140 const absl::Duration d = absl::UNIT(1.5); \
141 constexpr absl::Duration z = absl::ZeroDuration(); \
142 constexpr absl::Duration inf = absl::InfiniteDuration(); \
143 constexpr double dbl_inf = std::numeric_limits<double>::infinity(); \
144 EXPECT_EQ(kint64min, absl::ToInt64##UNIT(-inf)); \
145 EXPECT_EQ(-1, absl::ToInt64##UNIT(-d)); \
146 EXPECT_EQ(0, absl::ToInt64##UNIT(z)); \
147 EXPECT_EQ(1, absl::ToInt64##UNIT(d)); \
148 EXPECT_EQ(kint64max, absl::ToInt64##UNIT(inf)); \
149 EXPECT_EQ(-dbl_inf, absl::ToDouble##UNIT(-inf)); \
150 EXPECT_EQ(-1.5, absl::ToDouble##UNIT(-d)); \
151 EXPECT_EQ(0, absl::ToDouble##UNIT(z)); \
152 EXPECT_EQ(1.5, absl::ToDouble##UNIT(d)); \
153 EXPECT_EQ(dbl_inf, absl::ToDouble##UNIT(inf)); \
154 } while (0)
155
156 TEST_DURATION_CONVERSION(Nanoseconds);
157 TEST_DURATION_CONVERSION(Microseconds);
158 TEST_DURATION_CONVERSION(Milliseconds);
159 TEST_DURATION_CONVERSION(Seconds);
160 TEST_DURATION_CONVERSION(Minutes);
161 TEST_DURATION_CONVERSION(Hours);
162
163 #undef TEST_DURATION_CONVERSION
164 }
165
166 template <int64_t N>
TestToConversion()167 void TestToConversion() {
168 constexpr absl::Duration nano = absl::Nanoseconds(N);
169 EXPECT_EQ(N, absl::ToInt64Nanoseconds(nano));
170 EXPECT_EQ(0, absl::ToInt64Microseconds(nano));
171 EXPECT_EQ(0, absl::ToInt64Milliseconds(nano));
172 EXPECT_EQ(0, absl::ToInt64Seconds(nano));
173 EXPECT_EQ(0, absl::ToInt64Minutes(nano));
174 EXPECT_EQ(0, absl::ToInt64Hours(nano));
175 const absl::Duration micro = absl::Microseconds(N);
176 EXPECT_EQ(N * 1000, absl::ToInt64Nanoseconds(micro));
177 EXPECT_EQ(N, absl::ToInt64Microseconds(micro));
178 EXPECT_EQ(0, absl::ToInt64Milliseconds(micro));
179 EXPECT_EQ(0, absl::ToInt64Seconds(micro));
180 EXPECT_EQ(0, absl::ToInt64Minutes(micro));
181 EXPECT_EQ(0, absl::ToInt64Hours(micro));
182 const absl::Duration milli = absl::Milliseconds(N);
183 EXPECT_EQ(N * 1000 * 1000, absl::ToInt64Nanoseconds(milli));
184 EXPECT_EQ(N * 1000, absl::ToInt64Microseconds(milli));
185 EXPECT_EQ(N, absl::ToInt64Milliseconds(milli));
186 EXPECT_EQ(0, absl::ToInt64Seconds(milli));
187 EXPECT_EQ(0, absl::ToInt64Minutes(milli));
188 EXPECT_EQ(0, absl::ToInt64Hours(milli));
189 const absl::Duration sec = absl::Seconds(N);
190 EXPECT_EQ(N * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(sec));
191 EXPECT_EQ(N * 1000 * 1000, absl::ToInt64Microseconds(sec));
192 EXPECT_EQ(N * 1000, absl::ToInt64Milliseconds(sec));
193 EXPECT_EQ(N, absl::ToInt64Seconds(sec));
194 EXPECT_EQ(0, absl::ToInt64Minutes(sec));
195 EXPECT_EQ(0, absl::ToInt64Hours(sec));
196 const absl::Duration min = absl::Minutes(N);
197 EXPECT_EQ(N * 60 * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(min));
198 EXPECT_EQ(N * 60 * 1000 * 1000, absl::ToInt64Microseconds(min));
199 EXPECT_EQ(N * 60 * 1000, absl::ToInt64Milliseconds(min));
200 EXPECT_EQ(N * 60, absl::ToInt64Seconds(min));
201 EXPECT_EQ(N, absl::ToInt64Minutes(min));
202 EXPECT_EQ(0, absl::ToInt64Hours(min));
203 const absl::Duration hour = absl::Hours(N);
204 EXPECT_EQ(N * 60 * 60 * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(hour));
205 EXPECT_EQ(N * 60 * 60 * 1000 * 1000, absl::ToInt64Microseconds(hour));
206 EXPECT_EQ(N * 60 * 60 * 1000, absl::ToInt64Milliseconds(hour));
207 EXPECT_EQ(N * 60 * 60, absl::ToInt64Seconds(hour));
208 EXPECT_EQ(N * 60, absl::ToInt64Minutes(hour));
209 EXPECT_EQ(N, absl::ToInt64Hours(hour));
210 }
211
TEST(Duration,ToConversionDeprecated)212 TEST(Duration, ToConversionDeprecated) {
213 TestToConversion<43>();
214 TestToConversion<1>();
215 TestToConversion<0>();
216 TestToConversion<-1>();
217 TestToConversion<-43>();
218 }
219
220 template <int64_t N>
TestFromChronoBasicEquality()221 void TestFromChronoBasicEquality() {
222 using std::chrono::nanoseconds;
223 using std::chrono::microseconds;
224 using std::chrono::milliseconds;
225 using std::chrono::seconds;
226 using std::chrono::minutes;
227 using std::chrono::hours;
228
229 static_assert(absl::Nanoseconds(N) == absl::FromChrono(nanoseconds(N)), "");
230 static_assert(absl::Microseconds(N) == absl::FromChrono(microseconds(N)), "");
231 static_assert(absl::Milliseconds(N) == absl::FromChrono(milliseconds(N)), "");
232 static_assert(absl::Seconds(N) == absl::FromChrono(seconds(N)), "");
233 static_assert(absl::Minutes(N) == absl::FromChrono(minutes(N)), "");
234 static_assert(absl::Hours(N) == absl::FromChrono(hours(N)), "");
235 }
236
TEST(Duration,FromChrono)237 TEST(Duration, FromChrono) {
238 TestFromChronoBasicEquality<-123>();
239 TestFromChronoBasicEquality<-1>();
240 TestFromChronoBasicEquality<0>();
241 TestFromChronoBasicEquality<1>();
242 TestFromChronoBasicEquality<123>();
243
244 // Minutes (might, depending on the platform) saturate at +inf.
245 const auto chrono_minutes_max = std::chrono::minutes::max();
246 const auto minutes_max = absl::FromChrono(chrono_minutes_max);
247 const int64_t minutes_max_count = chrono_minutes_max.count();
248 if (minutes_max_count > kint64max / 60) {
249 EXPECT_EQ(absl::InfiniteDuration(), minutes_max);
250 } else {
251 EXPECT_EQ(absl::Minutes(minutes_max_count), minutes_max);
252 }
253
254 // Minutes (might, depending on the platform) saturate at -inf.
255 const auto chrono_minutes_min = std::chrono::minutes::min();
256 const auto minutes_min = absl::FromChrono(chrono_minutes_min);
257 const int64_t minutes_min_count = chrono_minutes_min.count();
258 if (minutes_min_count < kint64min / 60) {
259 EXPECT_EQ(-absl::InfiniteDuration(), minutes_min);
260 } else {
261 EXPECT_EQ(absl::Minutes(minutes_min_count), minutes_min);
262 }
263
264 // Hours (might, depending on the platform) saturate at +inf.
265 const auto chrono_hours_max = std::chrono::hours::max();
266 const auto hours_max = absl::FromChrono(chrono_hours_max);
267 const int64_t hours_max_count = chrono_hours_max.count();
268 if (hours_max_count > kint64max / 3600) {
269 EXPECT_EQ(absl::InfiniteDuration(), hours_max);
270 } else {
271 EXPECT_EQ(absl::Hours(hours_max_count), hours_max);
272 }
273
274 // Hours (might, depending on the platform) saturate at -inf.
275 const auto chrono_hours_min = std::chrono::hours::min();
276 const auto hours_min = absl::FromChrono(chrono_hours_min);
277 const int64_t hours_min_count = chrono_hours_min.count();
278 if (hours_min_count < kint64min / 3600) {
279 EXPECT_EQ(-absl::InfiniteDuration(), hours_min);
280 } else {
281 EXPECT_EQ(absl::Hours(hours_min_count), hours_min);
282 }
283 }
284
285 template <int64_t N>
TestToChrono()286 void TestToChrono() {
287 using std::chrono::nanoseconds;
288 using std::chrono::microseconds;
289 using std::chrono::milliseconds;
290 using std::chrono::seconds;
291 using std::chrono::minutes;
292 using std::chrono::hours;
293
294 EXPECT_EQ(nanoseconds(N), absl::ToChronoNanoseconds(absl::Nanoseconds(N)));
295 EXPECT_EQ(microseconds(N), absl::ToChronoMicroseconds(absl::Microseconds(N)));
296 EXPECT_EQ(milliseconds(N), absl::ToChronoMilliseconds(absl::Milliseconds(N)));
297 EXPECT_EQ(seconds(N), absl::ToChronoSeconds(absl::Seconds(N)));
298
299 constexpr auto absl_minutes = absl::Minutes(N);
300 auto chrono_minutes = minutes(N);
301 if (absl_minutes == -absl::InfiniteDuration()) {
302 chrono_minutes = minutes::min();
303 } else if (absl_minutes == absl::InfiniteDuration()) {
304 chrono_minutes = minutes::max();
305 }
306 EXPECT_EQ(chrono_minutes, absl::ToChronoMinutes(absl_minutes));
307
308 constexpr auto absl_hours = absl::Hours(N);
309 auto chrono_hours = hours(N);
310 if (absl_hours == -absl::InfiniteDuration()) {
311 chrono_hours = hours::min();
312 } else if (absl_hours == absl::InfiniteDuration()) {
313 chrono_hours = hours::max();
314 }
315 EXPECT_EQ(chrono_hours, absl::ToChronoHours(absl_hours));
316 }
317
TEST(Duration,ToChrono)318 TEST(Duration, ToChrono) {
319 using std::chrono::nanoseconds;
320 using std::chrono::microseconds;
321 using std::chrono::milliseconds;
322 using std::chrono::seconds;
323 using std::chrono::minutes;
324 using std::chrono::hours;
325
326 TestToChrono<kint64min>();
327 TestToChrono<-1>();
328 TestToChrono<0>();
329 TestToChrono<1>();
330 TestToChrono<kint64max>();
331
332 // Verify truncation toward zero.
333 const auto tick = absl::Nanoseconds(1) / 4;
334 EXPECT_EQ(nanoseconds(0), absl::ToChronoNanoseconds(tick));
335 EXPECT_EQ(nanoseconds(0), absl::ToChronoNanoseconds(-tick));
336 EXPECT_EQ(microseconds(0), absl::ToChronoMicroseconds(tick));
337 EXPECT_EQ(microseconds(0), absl::ToChronoMicroseconds(-tick));
338 EXPECT_EQ(milliseconds(0), absl::ToChronoMilliseconds(tick));
339 EXPECT_EQ(milliseconds(0), absl::ToChronoMilliseconds(-tick));
340 EXPECT_EQ(seconds(0), absl::ToChronoSeconds(tick));
341 EXPECT_EQ(seconds(0), absl::ToChronoSeconds(-tick));
342 EXPECT_EQ(minutes(0), absl::ToChronoMinutes(tick));
343 EXPECT_EQ(minutes(0), absl::ToChronoMinutes(-tick));
344 EXPECT_EQ(hours(0), absl::ToChronoHours(tick));
345 EXPECT_EQ(hours(0), absl::ToChronoHours(-tick));
346
347 // Verifies +/- infinity saturation at max/min.
348 constexpr auto inf = absl::InfiniteDuration();
349 EXPECT_EQ(nanoseconds::min(), absl::ToChronoNanoseconds(-inf));
350 EXPECT_EQ(nanoseconds::max(), absl::ToChronoNanoseconds(inf));
351 EXPECT_EQ(microseconds::min(), absl::ToChronoMicroseconds(-inf));
352 EXPECT_EQ(microseconds::max(), absl::ToChronoMicroseconds(inf));
353 EXPECT_EQ(milliseconds::min(), absl::ToChronoMilliseconds(-inf));
354 EXPECT_EQ(milliseconds::max(), absl::ToChronoMilliseconds(inf));
355 EXPECT_EQ(seconds::min(), absl::ToChronoSeconds(-inf));
356 EXPECT_EQ(seconds::max(), absl::ToChronoSeconds(inf));
357 EXPECT_EQ(minutes::min(), absl::ToChronoMinutes(-inf));
358 EXPECT_EQ(minutes::max(), absl::ToChronoMinutes(inf));
359 EXPECT_EQ(hours::min(), absl::ToChronoHours(-inf));
360 EXPECT_EQ(hours::max(), absl::ToChronoHours(inf));
361 }
362
TEST(Duration,FactoryOverloads)363 TEST(Duration, FactoryOverloads) {
364 enum E { kOne = 1 };
365 #define TEST_FACTORY_OVERLOADS(NAME) \
366 EXPECT_EQ(1, NAME(kOne) / NAME(kOne)); \
367 EXPECT_EQ(1, NAME(static_cast<int8_t>(1)) / NAME(1)); \
368 EXPECT_EQ(1, NAME(static_cast<int16_t>(1)) / NAME(1)); \
369 EXPECT_EQ(1, NAME(static_cast<int32_t>(1)) / NAME(1)); \
370 EXPECT_EQ(1, NAME(static_cast<int64_t>(1)) / NAME(1)); \
371 EXPECT_EQ(1, NAME(static_cast<uint8_t>(1)) / NAME(1)); \
372 EXPECT_EQ(1, NAME(static_cast<uint16_t>(1)) / NAME(1)); \
373 EXPECT_EQ(1, NAME(static_cast<uint32_t>(1)) / NAME(1)); \
374 EXPECT_EQ(1, NAME(static_cast<uint64_t>(1)) / NAME(1)); \
375 EXPECT_EQ(NAME(1) / 2, NAME(static_cast<float>(0.5))); \
376 EXPECT_EQ(NAME(1) / 2, NAME(static_cast<double>(0.5))); \
377 EXPECT_EQ(1.5, absl::FDivDuration(NAME(static_cast<float>(1.5)), NAME(1))); \
378 EXPECT_EQ(1.5, absl::FDivDuration(NAME(static_cast<double>(1.5)), NAME(1)));
379
380 TEST_FACTORY_OVERLOADS(absl::Nanoseconds);
381 TEST_FACTORY_OVERLOADS(absl::Microseconds);
382 TEST_FACTORY_OVERLOADS(absl::Milliseconds);
383 TEST_FACTORY_OVERLOADS(absl::Seconds);
384 TEST_FACTORY_OVERLOADS(absl::Minutes);
385 TEST_FACTORY_OVERLOADS(absl::Hours);
386
387 #undef TEST_FACTORY_OVERLOADS
388
389 EXPECT_EQ(absl::Milliseconds(1500), absl::Seconds(1.5));
390 EXPECT_LT(absl::Nanoseconds(1), absl::Nanoseconds(1.5));
391 EXPECT_GT(absl::Nanoseconds(2), absl::Nanoseconds(1.5));
392
393 const double dbl_inf = std::numeric_limits<double>::infinity();
394 EXPECT_EQ(absl::InfiniteDuration(), absl::Nanoseconds(dbl_inf));
395 EXPECT_EQ(absl::InfiniteDuration(), absl::Microseconds(dbl_inf));
396 EXPECT_EQ(absl::InfiniteDuration(), absl::Milliseconds(dbl_inf));
397 EXPECT_EQ(absl::InfiniteDuration(), absl::Seconds(dbl_inf));
398 EXPECT_EQ(absl::InfiniteDuration(), absl::Minutes(dbl_inf));
399 EXPECT_EQ(absl::InfiniteDuration(), absl::Hours(dbl_inf));
400 EXPECT_EQ(-absl::InfiniteDuration(), absl::Nanoseconds(-dbl_inf));
401 EXPECT_EQ(-absl::InfiniteDuration(), absl::Microseconds(-dbl_inf));
402 EXPECT_EQ(-absl::InfiniteDuration(), absl::Milliseconds(-dbl_inf));
403 EXPECT_EQ(-absl::InfiniteDuration(), absl::Seconds(-dbl_inf));
404 EXPECT_EQ(-absl::InfiniteDuration(), absl::Minutes(-dbl_inf));
405 EXPECT_EQ(-absl::InfiniteDuration(), absl::Hours(-dbl_inf));
406 }
407
TEST(Duration,InfinityExamples)408 TEST(Duration, InfinityExamples) {
409 // These examples are used in the documentation in time.h. They are
410 // written so that they can be copy-n-pasted easily.
411
412 constexpr absl::Duration inf = absl::InfiniteDuration();
413 constexpr absl::Duration d = absl::Seconds(1); // Any finite duration
414
415 EXPECT_TRUE(inf == inf + inf);
416 EXPECT_TRUE(inf == inf + d);
417 EXPECT_TRUE(inf == inf - inf);
418 EXPECT_TRUE(-inf == d - inf);
419
420 EXPECT_TRUE(inf == d * 1e100);
421 EXPECT_TRUE(0 == d / inf); // NOLINT(readability/check)
422
423 // Division by zero returns infinity, or kint64min/MAX where necessary.
424 EXPECT_TRUE(inf == d / 0);
425 EXPECT_TRUE(kint64max == d / absl::ZeroDuration());
426 }
427
TEST(Duration,InfinityComparison)428 TEST(Duration, InfinityComparison) {
429 const absl::Duration inf = absl::InfiniteDuration();
430 const absl::Duration any_dur = absl::Seconds(1);
431
432 // Equality
433 EXPECT_EQ(inf, inf);
434 EXPECT_EQ(-inf, -inf);
435 EXPECT_NE(inf, -inf);
436 EXPECT_NE(any_dur, inf);
437 EXPECT_NE(any_dur, -inf);
438
439 // Relational
440 EXPECT_GT(inf, any_dur);
441 EXPECT_LT(-inf, any_dur);
442 EXPECT_LT(-inf, inf);
443 EXPECT_GT(inf, -inf);
444
445 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
446 EXPECT_EQ(inf <=> inf, std::strong_ordering::equal);
447 EXPECT_EQ(-inf <=> -inf, std::strong_ordering::equal);
448 EXPECT_EQ(-inf <=> inf, std::strong_ordering::less);
449 EXPECT_EQ(inf <=> -inf, std::strong_ordering::greater);
450 EXPECT_EQ(any_dur <=> inf, std::strong_ordering::less);
451 EXPECT_EQ(any_dur <=> -inf, std::strong_ordering::greater);
452 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
453 }
454
TEST(Duration,InfinityAddition)455 TEST(Duration, InfinityAddition) {
456 const absl::Duration sec_max = absl::Seconds(kint64max);
457 const absl::Duration sec_min = absl::Seconds(kint64min);
458 const absl::Duration any_dur = absl::Seconds(1);
459 const absl::Duration inf = absl::InfiniteDuration();
460
461 // Addition
462 EXPECT_EQ(inf, inf + inf);
463 EXPECT_EQ(inf, inf + -inf);
464 EXPECT_EQ(-inf, -inf + inf);
465 EXPECT_EQ(-inf, -inf + -inf);
466
467 EXPECT_EQ(inf, inf + any_dur);
468 EXPECT_EQ(inf, any_dur + inf);
469 EXPECT_EQ(-inf, -inf + any_dur);
470 EXPECT_EQ(-inf, any_dur + -inf);
471
472 // Interesting case
473 absl::Duration almost_inf = sec_max + absl::Nanoseconds(999999999);
474 EXPECT_GT(inf, almost_inf);
475 almost_inf += -absl::Nanoseconds(999999999);
476 EXPECT_GT(inf, almost_inf);
477
478 // Addition overflow/underflow
479 EXPECT_EQ(inf, sec_max + absl::Seconds(1));
480 EXPECT_EQ(inf, sec_max + sec_max);
481 EXPECT_EQ(-inf, sec_min + -absl::Seconds(1));
482 EXPECT_EQ(-inf, sec_min + -sec_max);
483
484 // For reference: IEEE 754 behavior
485 const double dbl_inf = std::numeric_limits<double>::infinity();
486 EXPECT_TRUE(std::isinf(dbl_inf + dbl_inf));
487 EXPECT_TRUE(std::isnan(dbl_inf + -dbl_inf)); // We return inf
488 EXPECT_TRUE(std::isnan(-dbl_inf + dbl_inf)); // We return inf
489 EXPECT_TRUE(std::isinf(-dbl_inf + -dbl_inf));
490 }
491
TEST(Duration,InfinitySubtraction)492 TEST(Duration, InfinitySubtraction) {
493 const absl::Duration sec_max = absl::Seconds(kint64max);
494 const absl::Duration sec_min = absl::Seconds(kint64min);
495 const absl::Duration any_dur = absl::Seconds(1);
496 const absl::Duration inf = absl::InfiniteDuration();
497
498 // Subtraction
499 EXPECT_EQ(inf, inf - inf);
500 EXPECT_EQ(inf, inf - -inf);
501 EXPECT_EQ(-inf, -inf - inf);
502 EXPECT_EQ(-inf, -inf - -inf);
503
504 EXPECT_EQ(inf, inf - any_dur);
505 EXPECT_EQ(-inf, any_dur - inf);
506 EXPECT_EQ(-inf, -inf - any_dur);
507 EXPECT_EQ(inf, any_dur - -inf);
508
509 // Subtraction overflow/underflow
510 EXPECT_EQ(inf, sec_max - -absl::Seconds(1));
511 EXPECT_EQ(inf, sec_max - -sec_max);
512 EXPECT_EQ(-inf, sec_min - absl::Seconds(1));
513 EXPECT_EQ(-inf, sec_min - sec_max);
514
515 // Interesting case
516 absl::Duration almost_neg_inf = sec_min;
517 EXPECT_LT(-inf, almost_neg_inf);
518
519 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
520 EXPECT_EQ(-inf <=> almost_neg_inf, std::strong_ordering::less);
521 EXPECT_EQ(almost_neg_inf <=> -inf, std::strong_ordering::greater);
522 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
523
524 almost_neg_inf -= -absl::Nanoseconds(1);
525 EXPECT_LT(-inf, almost_neg_inf);
526
527 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
528 EXPECT_EQ(-inf <=> almost_neg_inf, std::strong_ordering::less);
529 EXPECT_EQ(almost_neg_inf <=> -inf, std::strong_ordering::greater);
530 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
531
532 // For reference: IEEE 754 behavior
533 const double dbl_inf = std::numeric_limits<double>::infinity();
534 EXPECT_TRUE(std::isnan(dbl_inf - dbl_inf)); // We return inf
535 EXPECT_TRUE(std::isinf(dbl_inf - -dbl_inf));
536 EXPECT_TRUE(std::isinf(-dbl_inf - dbl_inf));
537 EXPECT_TRUE(std::isnan(-dbl_inf - -dbl_inf)); // We return inf
538 }
539
TEST(Duration,InfinityMultiplication)540 TEST(Duration, InfinityMultiplication) {
541 const absl::Duration sec_max = absl::Seconds(kint64max);
542 const absl::Duration sec_min = absl::Seconds(kint64min);
543 const absl::Duration inf = absl::InfiniteDuration();
544
545 #define TEST_INF_MUL_WITH_TYPE(T) \
546 EXPECT_EQ(inf, inf * static_cast<T>(2)); \
547 EXPECT_EQ(-inf, inf * static_cast<T>(-2)); \
548 EXPECT_EQ(-inf, -inf * static_cast<T>(2)); \
549 EXPECT_EQ(inf, -inf * static_cast<T>(-2)); \
550 EXPECT_EQ(inf, inf * static_cast<T>(0)); \
551 EXPECT_EQ(-inf, -inf * static_cast<T>(0)); \
552 EXPECT_EQ(inf, sec_max * static_cast<T>(2)); \
553 EXPECT_EQ(inf, sec_min * static_cast<T>(-2)); \
554 EXPECT_EQ(inf, (sec_max / static_cast<T>(2)) * static_cast<T>(3)); \
555 EXPECT_EQ(-inf, sec_max * static_cast<T>(-2)); \
556 EXPECT_EQ(-inf, sec_min * static_cast<T>(2)); \
557 EXPECT_EQ(-inf, (sec_min / static_cast<T>(2)) * static_cast<T>(3));
558
559 TEST_INF_MUL_WITH_TYPE(int64_t); // NOLINT(readability/function)
560 TEST_INF_MUL_WITH_TYPE(double); // NOLINT(readability/function)
561
562 #undef TEST_INF_MUL_WITH_TYPE
563
564 const double dbl_inf = std::numeric_limits<double>::infinity();
565 EXPECT_EQ(inf, inf * dbl_inf);
566 EXPECT_EQ(-inf, -inf * dbl_inf);
567 EXPECT_EQ(-inf, inf * -dbl_inf);
568 EXPECT_EQ(inf, -inf * -dbl_inf);
569
570 const absl::Duration any_dur = absl::Seconds(1);
571 EXPECT_EQ(inf, any_dur * dbl_inf);
572 EXPECT_EQ(-inf, -any_dur * dbl_inf);
573 EXPECT_EQ(-inf, any_dur * -dbl_inf);
574 EXPECT_EQ(inf, -any_dur * -dbl_inf);
575
576 // Fixed-point multiplication will produce a finite value, whereas floating
577 // point fuzziness will overflow to inf.
578 EXPECT_NE(absl::InfiniteDuration(), absl::Seconds(1) * kint64max);
579 EXPECT_EQ(inf, absl::Seconds(1) * static_cast<double>(kint64max));
580 EXPECT_NE(-absl::InfiniteDuration(), absl::Seconds(1) * kint64min);
581 EXPECT_EQ(-inf, absl::Seconds(1) * static_cast<double>(kint64min));
582
583 // Note that sec_max * or / by 1.0 overflows to inf due to the 53-bit
584 // limitations of double.
585 EXPECT_NE(inf, sec_max);
586 EXPECT_NE(inf, sec_max / 1);
587 EXPECT_EQ(inf, sec_max / 1.0);
588 EXPECT_NE(inf, sec_max * 1);
589 EXPECT_EQ(inf, sec_max * 1.0);
590 }
591
TEST(Duration,InfinityDivision)592 TEST(Duration, InfinityDivision) {
593 const absl::Duration sec_max = absl::Seconds(kint64max);
594 const absl::Duration sec_min = absl::Seconds(kint64min);
595 const absl::Duration inf = absl::InfiniteDuration();
596
597 // Division of Duration by a double
598 #define TEST_INF_DIV_WITH_TYPE(T) \
599 EXPECT_EQ(inf, inf / static_cast<T>(2)); \
600 EXPECT_EQ(-inf, inf / static_cast<T>(-2)); \
601 EXPECT_EQ(-inf, -inf / static_cast<T>(2)); \
602 EXPECT_EQ(inf, -inf / static_cast<T>(-2));
603
604 TEST_INF_DIV_WITH_TYPE(int64_t); // NOLINT(readability/function)
605 TEST_INF_DIV_WITH_TYPE(double); // NOLINT(readability/function)
606
607 #undef TEST_INF_DIV_WITH_TYPE
608
609 // Division of Duration by a double overflow/underflow
610 EXPECT_EQ(inf, sec_max / 0.5);
611 EXPECT_EQ(inf, sec_min / -0.5);
612 EXPECT_EQ(inf, ((sec_max / 0.5) + absl::Seconds(1)) / 0.5);
613 EXPECT_EQ(-inf, sec_max / -0.5);
614 EXPECT_EQ(-inf, sec_min / 0.5);
615 EXPECT_EQ(-inf, ((sec_min / 0.5) - absl::Seconds(1)) / 0.5);
616
617 const double dbl_inf = std::numeric_limits<double>::infinity();
618 EXPECT_EQ(inf, inf / dbl_inf);
619 EXPECT_EQ(-inf, inf / -dbl_inf);
620 EXPECT_EQ(-inf, -inf / dbl_inf);
621 EXPECT_EQ(inf, -inf / -dbl_inf);
622
623 const absl::Duration any_dur = absl::Seconds(1);
624 EXPECT_EQ(absl::ZeroDuration(), any_dur / dbl_inf);
625 EXPECT_EQ(absl::ZeroDuration(), any_dur / -dbl_inf);
626 EXPECT_EQ(absl::ZeroDuration(), -any_dur / dbl_inf);
627 EXPECT_EQ(absl::ZeroDuration(), -any_dur / -dbl_inf);
628 }
629
TEST(Duration,InfinityModulus)630 TEST(Duration, InfinityModulus) {
631 const absl::Duration sec_max = absl::Seconds(kint64max);
632 const absl::Duration any_dur = absl::Seconds(1);
633 const absl::Duration inf = absl::InfiniteDuration();
634
635 EXPECT_EQ(inf, inf % inf);
636 EXPECT_EQ(inf, inf % -inf);
637 EXPECT_EQ(-inf, -inf % -inf);
638 EXPECT_EQ(-inf, -inf % inf);
639
640 EXPECT_EQ(any_dur, any_dur % inf);
641 EXPECT_EQ(any_dur, any_dur % -inf);
642 EXPECT_EQ(-any_dur, -any_dur % inf);
643 EXPECT_EQ(-any_dur, -any_dur % -inf);
644
645 EXPECT_EQ(inf, inf % -any_dur);
646 EXPECT_EQ(inf, inf % any_dur);
647 EXPECT_EQ(-inf, -inf % -any_dur);
648 EXPECT_EQ(-inf, -inf % any_dur);
649
650 // Remainder isn't affected by overflow.
651 EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Seconds(1));
652 EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Milliseconds(1));
653 EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Microseconds(1));
654 EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Nanoseconds(1));
655 EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Nanoseconds(1) / 4);
656 }
657
TEST(Duration,InfinityIDiv)658 TEST(Duration, InfinityIDiv) {
659 const absl::Duration sec_max = absl::Seconds(kint64max);
660 const absl::Duration any_dur = absl::Seconds(1);
661 const absl::Duration inf = absl::InfiniteDuration();
662 const double dbl_inf = std::numeric_limits<double>::infinity();
663
664 // IDivDuration (int64_t return value + a remainer)
665 absl::Duration rem = absl::ZeroDuration();
666 EXPECT_EQ(kint64max, absl::IDivDuration(inf, inf, &rem));
667 EXPECT_EQ(inf, rem);
668
669 rem = absl::ZeroDuration();
670 EXPECT_EQ(kint64max, absl::IDivDuration(-inf, -inf, &rem));
671 EXPECT_EQ(-inf, rem);
672
673 rem = absl::ZeroDuration();
674 EXPECT_EQ(kint64max, absl::IDivDuration(inf, any_dur, &rem));
675 EXPECT_EQ(inf, rem);
676
677 rem = absl::ZeroDuration();
678 EXPECT_EQ(0, absl::IDivDuration(any_dur, inf, &rem));
679 EXPECT_EQ(any_dur, rem);
680
681 rem = absl::ZeroDuration();
682 EXPECT_EQ(kint64max, absl::IDivDuration(-inf, -any_dur, &rem));
683 EXPECT_EQ(-inf, rem);
684
685 rem = absl::ZeroDuration();
686 EXPECT_EQ(0, absl::IDivDuration(-any_dur, -inf, &rem));
687 EXPECT_EQ(-any_dur, rem);
688
689 rem = absl::ZeroDuration();
690 EXPECT_EQ(kint64min, absl::IDivDuration(-inf, inf, &rem));
691 EXPECT_EQ(-inf, rem);
692
693 rem = absl::ZeroDuration();
694 EXPECT_EQ(kint64min, absl::IDivDuration(inf, -inf, &rem));
695 EXPECT_EQ(inf, rem);
696
697 rem = absl::ZeroDuration();
698 EXPECT_EQ(kint64min, absl::IDivDuration(-inf, any_dur, &rem));
699 EXPECT_EQ(-inf, rem);
700
701 rem = absl::ZeroDuration();
702 EXPECT_EQ(0, absl::IDivDuration(-any_dur, inf, &rem));
703 EXPECT_EQ(-any_dur, rem);
704
705 rem = absl::ZeroDuration();
706 EXPECT_EQ(kint64min, absl::IDivDuration(inf, -any_dur, &rem));
707 EXPECT_EQ(inf, rem);
708
709 rem = absl::ZeroDuration();
710 EXPECT_EQ(0, absl::IDivDuration(any_dur, -inf, &rem));
711 EXPECT_EQ(any_dur, rem);
712
713 // IDivDuration overflow/underflow
714 rem = any_dur;
715 EXPECT_EQ(kint64max,
716 absl::IDivDuration(sec_max, absl::Nanoseconds(1) / 4, &rem));
717 EXPECT_EQ(sec_max - absl::Nanoseconds(kint64max) / 4, rem);
718
719 rem = any_dur;
720 EXPECT_EQ(kint64max,
721 absl::IDivDuration(sec_max, absl::Milliseconds(1), &rem));
722 EXPECT_EQ(sec_max - absl::Milliseconds(kint64max), rem);
723
724 rem = any_dur;
725 EXPECT_EQ(kint64max,
726 absl::IDivDuration(-sec_max, -absl::Milliseconds(1), &rem));
727 EXPECT_EQ(-sec_max + absl::Milliseconds(kint64max), rem);
728
729 rem = any_dur;
730 EXPECT_EQ(kint64min,
731 absl::IDivDuration(-sec_max, absl::Milliseconds(1), &rem));
732 EXPECT_EQ(-sec_max - absl::Milliseconds(kint64min), rem);
733
734 rem = any_dur;
735 EXPECT_EQ(kint64min,
736 absl::IDivDuration(sec_max, -absl::Milliseconds(1), &rem));
737 EXPECT_EQ(sec_max + absl::Milliseconds(kint64min), rem);
738
739 //
740 // operator/(Duration, Duration) is a wrapper for IDivDuration().
741 //
742
743 // IEEE 754 says inf / inf should be nan, but int64_t doesn't have
744 // nan so we'll return kint64max/kint64min instead.
745 EXPECT_TRUE(std::isnan(dbl_inf / dbl_inf));
746 EXPECT_EQ(kint64max, inf / inf);
747 EXPECT_EQ(kint64max, -inf / -inf);
748 EXPECT_EQ(kint64min, -inf / inf);
749 EXPECT_EQ(kint64min, inf / -inf);
750
751 EXPECT_TRUE(std::isinf(dbl_inf / 2.0));
752 EXPECT_EQ(kint64max, inf / any_dur);
753 EXPECT_EQ(kint64max, -inf / -any_dur);
754 EXPECT_EQ(kint64min, -inf / any_dur);
755 EXPECT_EQ(kint64min, inf / -any_dur);
756
757 EXPECT_EQ(0.0, 2.0 / dbl_inf);
758 EXPECT_EQ(0, any_dur / inf);
759 EXPECT_EQ(0, any_dur / -inf);
760 EXPECT_EQ(0, -any_dur / inf);
761 EXPECT_EQ(0, -any_dur / -inf);
762 EXPECT_EQ(0, absl::ZeroDuration() / inf);
763
764 // Division of Duration by a Duration overflow/underflow
765 EXPECT_EQ(kint64max, sec_max / absl::Milliseconds(1));
766 EXPECT_EQ(kint64max, -sec_max / -absl::Milliseconds(1));
767 EXPECT_EQ(kint64min, -sec_max / absl::Milliseconds(1));
768 EXPECT_EQ(kint64min, sec_max / -absl::Milliseconds(1));
769 }
770
TEST(Duration,InfinityFDiv)771 TEST(Duration, InfinityFDiv) {
772 const absl::Duration any_dur = absl::Seconds(1);
773 const absl::Duration inf = absl::InfiniteDuration();
774 const double dbl_inf = std::numeric_limits<double>::infinity();
775
776 EXPECT_EQ(dbl_inf, absl::FDivDuration(inf, inf));
777 EXPECT_EQ(dbl_inf, absl::FDivDuration(-inf, -inf));
778 EXPECT_EQ(dbl_inf, absl::FDivDuration(inf, any_dur));
779 EXPECT_EQ(0.0, absl::FDivDuration(any_dur, inf));
780 EXPECT_EQ(dbl_inf, absl::FDivDuration(-inf, -any_dur));
781 EXPECT_EQ(0.0, absl::FDivDuration(-any_dur, -inf));
782
783 EXPECT_EQ(-dbl_inf, absl::FDivDuration(-inf, inf));
784 EXPECT_EQ(-dbl_inf, absl::FDivDuration(inf, -inf));
785 EXPECT_EQ(-dbl_inf, absl::FDivDuration(-inf, any_dur));
786 EXPECT_EQ(0.0, absl::FDivDuration(-any_dur, inf));
787 EXPECT_EQ(-dbl_inf, absl::FDivDuration(inf, -any_dur));
788 EXPECT_EQ(0.0, absl::FDivDuration(any_dur, -inf));
789 }
790
TEST(Duration,DivisionByZero)791 TEST(Duration, DivisionByZero) {
792 const absl::Duration zero = absl::ZeroDuration();
793 const absl::Duration inf = absl::InfiniteDuration();
794 const absl::Duration any_dur = absl::Seconds(1);
795 const double dbl_inf = std::numeric_limits<double>::infinity();
796 const double dbl_denorm = std::numeric_limits<double>::denorm_min();
797
798 // Operator/(Duration, double)
799 EXPECT_EQ(inf, zero / 0.0);
800 EXPECT_EQ(-inf, zero / -0.0);
801 EXPECT_EQ(inf, any_dur / 0.0);
802 EXPECT_EQ(-inf, any_dur / -0.0);
803 EXPECT_EQ(-inf, -any_dur / 0.0);
804 EXPECT_EQ(inf, -any_dur / -0.0);
805
806 // Tests dividing by a number very close to, but not quite zero.
807 EXPECT_EQ(zero, zero / dbl_denorm);
808 EXPECT_EQ(zero, zero / -dbl_denorm);
809 EXPECT_EQ(inf, any_dur / dbl_denorm);
810 EXPECT_EQ(-inf, any_dur / -dbl_denorm);
811 EXPECT_EQ(-inf, -any_dur / dbl_denorm);
812 EXPECT_EQ(inf, -any_dur / -dbl_denorm);
813
814 // IDiv
815 absl::Duration rem = zero;
816 EXPECT_EQ(kint64max, absl::IDivDuration(zero, zero, &rem));
817 EXPECT_EQ(inf, rem);
818
819 rem = zero;
820 EXPECT_EQ(kint64max, absl::IDivDuration(any_dur, zero, &rem));
821 EXPECT_EQ(inf, rem);
822
823 rem = zero;
824 EXPECT_EQ(kint64min, absl::IDivDuration(-any_dur, zero, &rem));
825 EXPECT_EQ(-inf, rem);
826
827 // Operator/(Duration, Duration)
828 EXPECT_EQ(kint64max, zero / zero);
829 EXPECT_EQ(kint64max, any_dur / zero);
830 EXPECT_EQ(kint64min, -any_dur / zero);
831
832 // FDiv
833 EXPECT_EQ(dbl_inf, absl::FDivDuration(zero, zero));
834 EXPECT_EQ(dbl_inf, absl::FDivDuration(any_dur, zero));
835 EXPECT_EQ(-dbl_inf, absl::FDivDuration(-any_dur, zero));
836 }
837
TEST(Duration,NaN)838 TEST(Duration, NaN) {
839 // Note that IEEE 754 does not define the behavior of a nan's sign when it is
840 // copied, so the code below allows for either + or - InfiniteDuration.
841 #define TEST_NAN_HANDLING(NAME, NAN) \
842 do { \
843 const auto inf = absl::InfiniteDuration(); \
844 auto x = NAME(NAN); \
845 EXPECT_TRUE(x == inf || x == -inf); \
846 auto y = NAME(42); \
847 y *= NAN; \
848 EXPECT_TRUE(y == inf || y == -inf); \
849 auto z = NAME(42); \
850 z /= NAN; \
851 EXPECT_TRUE(z == inf || z == -inf); \
852 } while (0)
853
854 const double nan = std::numeric_limits<double>::quiet_NaN();
855 TEST_NAN_HANDLING(absl::Nanoseconds, nan);
856 TEST_NAN_HANDLING(absl::Microseconds, nan);
857 TEST_NAN_HANDLING(absl::Milliseconds, nan);
858 TEST_NAN_HANDLING(absl::Seconds, nan);
859 TEST_NAN_HANDLING(absl::Minutes, nan);
860 TEST_NAN_HANDLING(absl::Hours, nan);
861
862 TEST_NAN_HANDLING(absl::Nanoseconds, -nan);
863 TEST_NAN_HANDLING(absl::Microseconds, -nan);
864 TEST_NAN_HANDLING(absl::Milliseconds, -nan);
865 TEST_NAN_HANDLING(absl::Seconds, -nan);
866 TEST_NAN_HANDLING(absl::Minutes, -nan);
867 TEST_NAN_HANDLING(absl::Hours, -nan);
868
869 #undef TEST_NAN_HANDLING
870 }
871
TEST(Duration,Range)872 TEST(Duration, Range) {
873 const absl::Duration range = ApproxYears(100 * 1e9);
874 const absl::Duration range_future = range;
875 const absl::Duration range_past = -range;
876
877 EXPECT_LT(range_future, absl::InfiniteDuration());
878 EXPECT_GT(range_past, -absl::InfiniteDuration());
879
880 const absl::Duration full_range = range_future - range_past;
881 EXPECT_GT(full_range, absl::ZeroDuration());
882 EXPECT_LT(full_range, absl::InfiniteDuration());
883
884 const absl::Duration neg_full_range = range_past - range_future;
885 EXPECT_LT(neg_full_range, absl::ZeroDuration());
886 EXPECT_GT(neg_full_range, -absl::InfiniteDuration());
887
888 EXPECT_LT(neg_full_range, full_range);
889 EXPECT_EQ(neg_full_range, -full_range);
890
891 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
892 EXPECT_EQ(range_future <=> absl::InfiniteDuration(),
893 std::strong_ordering::less);
894 EXPECT_EQ(range_past <=> -absl::InfiniteDuration(),
895 std::strong_ordering::greater);
896 EXPECT_EQ(full_range <=> absl::ZeroDuration(), //
897 std::strong_ordering::greater);
898 EXPECT_EQ(full_range <=> -absl::InfiniteDuration(),
899 std::strong_ordering::greater);
900 EXPECT_EQ(neg_full_range <=> -absl::InfiniteDuration(),
901 std::strong_ordering::greater);
902 EXPECT_EQ(neg_full_range <=> full_range, std::strong_ordering::less);
903 EXPECT_EQ(neg_full_range <=> -full_range, std::strong_ordering::equal);
904 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
905 }
906
TEST(Duration,RelationalOperators)907 TEST(Duration, RelationalOperators) {
908 #define TEST_REL_OPS(UNIT) \
909 static_assert(UNIT(2) == UNIT(2), ""); \
910 static_assert(UNIT(1) != UNIT(2), ""); \
911 static_assert(UNIT(1) < UNIT(2), ""); \
912 static_assert(UNIT(3) > UNIT(2), ""); \
913 static_assert(UNIT(1) <= UNIT(2), ""); \
914 static_assert(UNIT(2) <= UNIT(2), ""); \
915 static_assert(UNIT(3) >= UNIT(2), ""); \
916 static_assert(UNIT(2) >= UNIT(2), "");
917
918 TEST_REL_OPS(absl::Nanoseconds);
919 TEST_REL_OPS(absl::Microseconds);
920 TEST_REL_OPS(absl::Milliseconds);
921 TEST_REL_OPS(absl::Seconds);
922 TEST_REL_OPS(absl::Minutes);
923 TEST_REL_OPS(absl::Hours);
924
925 #undef TEST_REL_OPS
926 }
927
928 #ifdef ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
929
TEST(Duration,SpaceshipOperators)930 TEST(Duration, SpaceshipOperators) {
931 #define TEST_REL_OPS(UNIT) \
932 static_assert(UNIT(2) <=> UNIT(2) == std::strong_ordering::equal, ""); \
933 static_assert(UNIT(1) <=> UNIT(2) == std::strong_ordering::less, ""); \
934 static_assert(UNIT(3) <=> UNIT(2) == std::strong_ordering::greater, "");
935
936 TEST_REL_OPS(absl::Nanoseconds);
937 TEST_REL_OPS(absl::Microseconds);
938 TEST_REL_OPS(absl::Milliseconds);
939 TEST_REL_OPS(absl::Seconds);
940 TEST_REL_OPS(absl::Minutes);
941 TEST_REL_OPS(absl::Hours);
942
943 #undef TEST_REL_OPS
944 }
945
946 #endif // ABSL_INTERNAL_TIME_HAS_THREE_WAY_COMPARISON
947
TEST(Duration,Addition)948 TEST(Duration, Addition) {
949 #define TEST_ADD_OPS(UNIT) \
950 do { \
951 EXPECT_EQ(UNIT(2), UNIT(1) + UNIT(1)); \
952 EXPECT_EQ(UNIT(1), UNIT(2) - UNIT(1)); \
953 EXPECT_EQ(UNIT(0), UNIT(2) - UNIT(2)); \
954 EXPECT_EQ(UNIT(-1), UNIT(1) - UNIT(2)); \
955 EXPECT_EQ(UNIT(-2), UNIT(0) - UNIT(2)); \
956 EXPECT_EQ(UNIT(-2), UNIT(1) - UNIT(3)); \
957 absl::Duration a = UNIT(1); \
958 a += UNIT(1); \
959 EXPECT_EQ(UNIT(2), a); \
960 a -= UNIT(1); \
961 EXPECT_EQ(UNIT(1), a); \
962 } while (0)
963
964 TEST_ADD_OPS(absl::Nanoseconds);
965 TEST_ADD_OPS(absl::Microseconds);
966 TEST_ADD_OPS(absl::Milliseconds);
967 TEST_ADD_OPS(absl::Seconds);
968 TEST_ADD_OPS(absl::Minutes);
969 TEST_ADD_OPS(absl::Hours);
970
971 #undef TEST_ADD_OPS
972
973 EXPECT_EQ(absl::Seconds(2), absl::Seconds(3) - 2 * absl::Milliseconds(500));
974 EXPECT_EQ(absl::Seconds(2) + absl::Milliseconds(500),
975 absl::Seconds(3) - absl::Milliseconds(500));
976
977 EXPECT_EQ(absl::Seconds(1) + absl::Milliseconds(998),
978 absl::Milliseconds(999) + absl::Milliseconds(999));
979
980 EXPECT_EQ(absl::Milliseconds(-1),
981 absl::Milliseconds(998) - absl::Milliseconds(999));
982
983 // Tests fractions of a nanoseconds. These are implementation details only.
984 EXPECT_GT(absl::Nanoseconds(1), absl::Nanoseconds(1) / 2);
985 EXPECT_EQ(absl::Nanoseconds(1),
986 absl::Nanoseconds(1) / 2 + absl::Nanoseconds(1) / 2);
987 EXPECT_GT(absl::Nanoseconds(1) / 4, absl::Nanoseconds(0));
988 EXPECT_EQ(absl::Nanoseconds(1) / 8, absl::Nanoseconds(0));
989
990 // Tests subtraction that will cause wrap around of the rep_lo_ bits.
991 absl::Duration d_7_5 = absl::Seconds(7) + absl::Milliseconds(500);
992 absl::Duration d_3_7 = absl::Seconds(3) + absl::Milliseconds(700);
993 absl::Duration ans_3_8 = absl::Seconds(3) + absl::Milliseconds(800);
994 EXPECT_EQ(ans_3_8, d_7_5 - d_3_7);
995
996 // Subtracting min_duration
997 absl::Duration min_dur = absl::Seconds(kint64min);
998 EXPECT_EQ(absl::Seconds(0), min_dur - min_dur);
999 EXPECT_EQ(absl::Seconds(kint64max), absl::Seconds(-1) - min_dur);
1000 }
1001
TEST(Duration,Negation)1002 TEST(Duration, Negation) {
1003 // By storing negations of various values in constexpr variables we
1004 // verify that the initializers are constant expressions.
1005 constexpr absl::Duration negated_zero_duration = -absl::ZeroDuration();
1006 EXPECT_EQ(negated_zero_duration, absl::ZeroDuration());
1007
1008 constexpr absl::Duration negated_infinite_duration =
1009 -absl::InfiniteDuration();
1010 EXPECT_NE(negated_infinite_duration, absl::InfiniteDuration());
1011 EXPECT_EQ(-negated_infinite_duration, absl::InfiniteDuration());
1012
1013 // The public APIs to check if a duration is infinite depend on using
1014 // -InfiniteDuration(), but we're trying to test operator- here, so we
1015 // need to use the lower-level internal query IsInfiniteDuration.
1016 EXPECT_TRUE(
1017 absl::time_internal::IsInfiniteDuration(negated_infinite_duration));
1018
1019 // The largest Duration is kint64max seconds and kTicksPerSecond - 1 ticks.
1020 // Using the absl::time_internal::MakeDuration API is the cleanest way to
1021 // construct that Duration.
1022 constexpr absl::Duration max_duration = absl::time_internal::MakeDuration(
1023 kint64max, absl::time_internal::kTicksPerSecond - 1);
1024 constexpr absl::Duration negated_max_duration = -max_duration;
1025 // The largest negatable value is one tick above the minimum representable;
1026 // it's the negation of max_duration.
1027 constexpr absl::Duration nearly_min_duration =
1028 absl::time_internal::MakeDuration(kint64min, int64_t{1});
1029 constexpr absl::Duration negated_nearly_min_duration = -nearly_min_duration;
1030
1031 EXPECT_EQ(negated_max_duration, nearly_min_duration);
1032 EXPECT_EQ(negated_nearly_min_duration, max_duration);
1033 EXPECT_EQ(-(-max_duration), max_duration);
1034
1035 constexpr absl::Duration min_duration =
1036 absl::time_internal::MakeDuration(kint64min);
1037 constexpr absl::Duration negated_min_duration = -min_duration;
1038 EXPECT_EQ(negated_min_duration, absl::InfiniteDuration());
1039 }
1040
TEST(Duration,AbsoluteValue)1041 TEST(Duration, AbsoluteValue) {
1042 EXPECT_EQ(absl::ZeroDuration(), AbsDuration(absl::ZeroDuration()));
1043 EXPECT_EQ(absl::Seconds(1), AbsDuration(absl::Seconds(1)));
1044 EXPECT_EQ(absl::Seconds(1), AbsDuration(absl::Seconds(-1)));
1045
1046 EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(absl::InfiniteDuration()));
1047 EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(-absl::InfiniteDuration()));
1048
1049 absl::Duration max_dur =
1050 absl::Seconds(kint64max) + (absl::Seconds(1) - absl::Nanoseconds(1) / 4);
1051 EXPECT_EQ(max_dur, AbsDuration(max_dur));
1052
1053 absl::Duration min_dur = absl::Seconds(kint64min);
1054 EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(min_dur));
1055 EXPECT_EQ(max_dur, AbsDuration(min_dur + absl::Nanoseconds(1) / 4));
1056 }
1057
TEST(Duration,Multiplication)1058 TEST(Duration, Multiplication) {
1059 #define TEST_MUL_OPS(UNIT) \
1060 do { \
1061 EXPECT_EQ(UNIT(5), UNIT(2) * 2.5); \
1062 EXPECT_EQ(UNIT(2), UNIT(5) / 2.5); \
1063 EXPECT_EQ(UNIT(-5), UNIT(-2) * 2.5); \
1064 EXPECT_EQ(UNIT(-5), -UNIT(2) * 2.5); \
1065 EXPECT_EQ(UNIT(-5), UNIT(2) * -2.5); \
1066 EXPECT_EQ(UNIT(-2), UNIT(-5) / 2.5); \
1067 EXPECT_EQ(UNIT(-2), -UNIT(5) / 2.5); \
1068 EXPECT_EQ(UNIT(-2), UNIT(5) / -2.5); \
1069 EXPECT_EQ(UNIT(2), UNIT(11) % UNIT(3)); \
1070 absl::Duration a = UNIT(2); \
1071 a *= 2.5; \
1072 EXPECT_EQ(UNIT(5), a); \
1073 a /= 2.5; \
1074 EXPECT_EQ(UNIT(2), a); \
1075 a %= UNIT(1); \
1076 EXPECT_EQ(UNIT(0), a); \
1077 absl::Duration big = UNIT(1000000000); \
1078 big *= 3; \
1079 big /= 3; \
1080 EXPECT_EQ(UNIT(1000000000), big); \
1081 EXPECT_EQ(-UNIT(2), -UNIT(2)); \
1082 EXPECT_EQ(-UNIT(2), UNIT(2) * -1); \
1083 EXPECT_EQ(-UNIT(2), -1 * UNIT(2)); \
1084 EXPECT_EQ(-UNIT(-2), UNIT(2)); \
1085 EXPECT_EQ(2, UNIT(2) / UNIT(1)); \
1086 absl::Duration rem; \
1087 EXPECT_EQ(2, absl::IDivDuration(UNIT(2), UNIT(1), &rem)); \
1088 EXPECT_EQ(2.0, absl::FDivDuration(UNIT(2), UNIT(1))); \
1089 } while (0)
1090
1091 TEST_MUL_OPS(absl::Nanoseconds);
1092 TEST_MUL_OPS(absl::Microseconds);
1093 TEST_MUL_OPS(absl::Milliseconds);
1094 TEST_MUL_OPS(absl::Seconds);
1095 TEST_MUL_OPS(absl::Minutes);
1096 TEST_MUL_OPS(absl::Hours);
1097
1098 #undef TEST_MUL_OPS
1099
1100 // Ensures that multiplication and division by 1 with a maxed-out durations
1101 // doesn't lose precision.
1102 absl::Duration max_dur =
1103 absl::Seconds(kint64max) + (absl::Seconds(1) - absl::Nanoseconds(1) / 4);
1104 absl::Duration min_dur = absl::Seconds(kint64min);
1105 EXPECT_EQ(max_dur, max_dur * 1);
1106 EXPECT_EQ(max_dur, max_dur / 1);
1107 EXPECT_EQ(min_dur, min_dur * 1);
1108 EXPECT_EQ(min_dur, min_dur / 1);
1109
1110 // Tests division on a Duration with a large number of significant digits.
1111 // Tests when the digits span hi and lo as well as only in hi.
1112 absl::Duration sigfigs = absl::Seconds(2000000000) + absl::Nanoseconds(3);
1113 EXPECT_EQ(absl::Seconds(666666666) + absl::Nanoseconds(666666667) +
1114 absl::Nanoseconds(1) / 2,
1115 sigfigs / 3);
1116 sigfigs = absl::Seconds(int64_t{7000000000});
1117 EXPECT_EQ(absl::Seconds(2333333333) + absl::Nanoseconds(333333333) +
1118 absl::Nanoseconds(1) / 4,
1119 sigfigs / 3);
1120
1121 EXPECT_EQ(absl::Seconds(7) + absl::Milliseconds(500), absl::Seconds(3) * 2.5);
1122 EXPECT_EQ(absl::Seconds(8) * -1 + absl::Milliseconds(300),
1123 (absl::Seconds(2) + absl::Milliseconds(200)) * -3.5);
1124 EXPECT_EQ(-absl::Seconds(8) + absl::Milliseconds(300),
1125 (absl::Seconds(2) + absl::Milliseconds(200)) * -3.5);
1126 EXPECT_EQ(absl::Seconds(1) + absl::Milliseconds(875),
1127 (absl::Seconds(7) + absl::Milliseconds(500)) / 4);
1128 EXPECT_EQ(absl::Seconds(30),
1129 (absl::Seconds(7) + absl::Milliseconds(500)) / 0.25);
1130 EXPECT_EQ(absl::Seconds(3),
1131 (absl::Seconds(7) + absl::Milliseconds(500)) / 2.5);
1132
1133 // Tests division remainder.
1134 EXPECT_EQ(absl::Nanoseconds(0), absl::Nanoseconds(7) % absl::Nanoseconds(1));
1135 EXPECT_EQ(absl::Nanoseconds(0), absl::Nanoseconds(0) % absl::Nanoseconds(10));
1136 EXPECT_EQ(absl::Nanoseconds(2), absl::Nanoseconds(7) % absl::Nanoseconds(5));
1137 EXPECT_EQ(absl::Nanoseconds(2), absl::Nanoseconds(2) % absl::Nanoseconds(5));
1138
1139 EXPECT_EQ(absl::Nanoseconds(1), absl::Nanoseconds(10) % absl::Nanoseconds(3));
1140 EXPECT_EQ(absl::Nanoseconds(1),
1141 absl::Nanoseconds(10) % absl::Nanoseconds(-3));
1142 EXPECT_EQ(absl::Nanoseconds(-1),
1143 absl::Nanoseconds(-10) % absl::Nanoseconds(3));
1144 EXPECT_EQ(absl::Nanoseconds(-1),
1145 absl::Nanoseconds(-10) % absl::Nanoseconds(-3));
1146
1147 EXPECT_EQ(absl::Milliseconds(100),
1148 absl::Seconds(1) % absl::Milliseconds(300));
1149 EXPECT_EQ(
1150 absl::Milliseconds(300),
1151 (absl::Seconds(3) + absl::Milliseconds(800)) % absl::Milliseconds(500));
1152
1153 EXPECT_EQ(absl::Nanoseconds(1), absl::Nanoseconds(1) % absl::Seconds(1));
1154 EXPECT_EQ(absl::Nanoseconds(-1), absl::Nanoseconds(-1) % absl::Seconds(1));
1155 EXPECT_EQ(0, absl::Nanoseconds(-1) / absl::Seconds(1)); // Actual -1e-9
1156
1157 // Tests identity a = (a/b)*b + a%b
1158 #define TEST_MOD_IDENTITY(a, b) \
1159 EXPECT_EQ((a), ((a) / (b))*(b) + ((a)%(b)))
1160
1161 TEST_MOD_IDENTITY(absl::Seconds(0), absl::Seconds(2));
1162 TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(1));
1163 TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(2));
1164 TEST_MOD_IDENTITY(absl::Seconds(2), absl::Seconds(1));
1165
1166 TEST_MOD_IDENTITY(absl::Seconds(-2), absl::Seconds(1));
1167 TEST_MOD_IDENTITY(absl::Seconds(2), absl::Seconds(-1));
1168 TEST_MOD_IDENTITY(absl::Seconds(-2), absl::Seconds(-1));
1169
1170 TEST_MOD_IDENTITY(absl::Nanoseconds(0), absl::Nanoseconds(2));
1171 TEST_MOD_IDENTITY(absl::Nanoseconds(1), absl::Nanoseconds(1));
1172 TEST_MOD_IDENTITY(absl::Nanoseconds(1), absl::Nanoseconds(2));
1173 TEST_MOD_IDENTITY(absl::Nanoseconds(2), absl::Nanoseconds(1));
1174
1175 TEST_MOD_IDENTITY(absl::Nanoseconds(-2), absl::Nanoseconds(1));
1176 TEST_MOD_IDENTITY(absl::Nanoseconds(2), absl::Nanoseconds(-1));
1177 TEST_MOD_IDENTITY(absl::Nanoseconds(-2), absl::Nanoseconds(-1));
1178
1179 // Mixed seconds + subseconds
1180 absl::Duration mixed_a = absl::Seconds(1) + absl::Nanoseconds(2);
1181 absl::Duration mixed_b = absl::Seconds(1) + absl::Nanoseconds(3);
1182
1183 TEST_MOD_IDENTITY(absl::Seconds(0), mixed_a);
1184 TEST_MOD_IDENTITY(mixed_a, mixed_a);
1185 TEST_MOD_IDENTITY(mixed_a, mixed_b);
1186 TEST_MOD_IDENTITY(mixed_b, mixed_a);
1187
1188 TEST_MOD_IDENTITY(-mixed_a, mixed_b);
1189 TEST_MOD_IDENTITY(mixed_a, -mixed_b);
1190 TEST_MOD_IDENTITY(-mixed_a, -mixed_b);
1191
1192 #undef TEST_MOD_IDENTITY
1193 }
1194
TEST(Duration,Truncation)1195 TEST(Duration, Truncation) {
1196 const absl::Duration d = absl::Nanoseconds(1234567890);
1197 const absl::Duration inf = absl::InfiniteDuration();
1198 for (int unit_sign : {1, -1}) { // sign shouldn't matter
1199 EXPECT_EQ(absl::Nanoseconds(1234567890),
1200 Trunc(d, unit_sign * absl::Nanoseconds(1)));
1201 EXPECT_EQ(absl::Microseconds(1234567),
1202 Trunc(d, unit_sign * absl::Microseconds(1)));
1203 EXPECT_EQ(absl::Milliseconds(1234),
1204 Trunc(d, unit_sign * absl::Milliseconds(1)));
1205 EXPECT_EQ(absl::Seconds(1), Trunc(d, unit_sign * absl::Seconds(1)));
1206 EXPECT_EQ(inf, Trunc(inf, unit_sign * absl::Seconds(1)));
1207
1208 EXPECT_EQ(absl::Nanoseconds(-1234567890),
1209 Trunc(-d, unit_sign * absl::Nanoseconds(1)));
1210 EXPECT_EQ(absl::Microseconds(-1234567),
1211 Trunc(-d, unit_sign * absl::Microseconds(1)));
1212 EXPECT_EQ(absl::Milliseconds(-1234),
1213 Trunc(-d, unit_sign * absl::Milliseconds(1)));
1214 EXPECT_EQ(absl::Seconds(-1), Trunc(-d, unit_sign * absl::Seconds(1)));
1215 EXPECT_EQ(-inf, Trunc(-inf, unit_sign * absl::Seconds(1)));
1216 }
1217 }
1218
TEST(Duration,Flooring)1219 TEST(Duration, Flooring) {
1220 const absl::Duration d = absl::Nanoseconds(1234567890);
1221 const absl::Duration inf = absl::InfiniteDuration();
1222 for (int unit_sign : {1, -1}) { // sign shouldn't matter
1223 EXPECT_EQ(absl::Nanoseconds(1234567890),
1224 absl::Floor(d, unit_sign * absl::Nanoseconds(1)));
1225 EXPECT_EQ(absl::Microseconds(1234567),
1226 absl::Floor(d, unit_sign * absl::Microseconds(1)));
1227 EXPECT_EQ(absl::Milliseconds(1234),
1228 absl::Floor(d, unit_sign * absl::Milliseconds(1)));
1229 EXPECT_EQ(absl::Seconds(1), absl::Floor(d, unit_sign * absl::Seconds(1)));
1230 EXPECT_EQ(inf, absl::Floor(inf, unit_sign * absl::Seconds(1)));
1231
1232 EXPECT_EQ(absl::Nanoseconds(-1234567890),
1233 absl::Floor(-d, unit_sign * absl::Nanoseconds(1)));
1234 EXPECT_EQ(absl::Microseconds(-1234568),
1235 absl::Floor(-d, unit_sign * absl::Microseconds(1)));
1236 EXPECT_EQ(absl::Milliseconds(-1235),
1237 absl::Floor(-d, unit_sign * absl::Milliseconds(1)));
1238 EXPECT_EQ(absl::Seconds(-2), absl::Floor(-d, unit_sign * absl::Seconds(1)));
1239 EXPECT_EQ(-inf, absl::Floor(-inf, unit_sign * absl::Seconds(1)));
1240 }
1241 }
1242
TEST(Duration,Ceiling)1243 TEST(Duration, Ceiling) {
1244 const absl::Duration d = absl::Nanoseconds(1234567890);
1245 const absl::Duration inf = absl::InfiniteDuration();
1246 for (int unit_sign : {1, -1}) { // // sign shouldn't matter
1247 EXPECT_EQ(absl::Nanoseconds(1234567890),
1248 absl::Ceil(d, unit_sign * absl::Nanoseconds(1)));
1249 EXPECT_EQ(absl::Microseconds(1234568),
1250 absl::Ceil(d, unit_sign * absl::Microseconds(1)));
1251 EXPECT_EQ(absl::Milliseconds(1235),
1252 absl::Ceil(d, unit_sign * absl::Milliseconds(1)));
1253 EXPECT_EQ(absl::Seconds(2), absl::Ceil(d, unit_sign * absl::Seconds(1)));
1254 EXPECT_EQ(inf, absl::Ceil(inf, unit_sign * absl::Seconds(1)));
1255
1256 EXPECT_EQ(absl::Nanoseconds(-1234567890),
1257 absl::Ceil(-d, unit_sign * absl::Nanoseconds(1)));
1258 EXPECT_EQ(absl::Microseconds(-1234567),
1259 absl::Ceil(-d, unit_sign * absl::Microseconds(1)));
1260 EXPECT_EQ(absl::Milliseconds(-1234),
1261 absl::Ceil(-d, unit_sign * absl::Milliseconds(1)));
1262 EXPECT_EQ(absl::Seconds(-1), absl::Ceil(-d, unit_sign * absl::Seconds(1)));
1263 EXPECT_EQ(-inf, absl::Ceil(-inf, unit_sign * absl::Seconds(1)));
1264 }
1265 }
1266
TEST(Duration,RoundTripUnits)1267 TEST(Duration, RoundTripUnits) {
1268 const int kRange = 100000;
1269
1270 #define ROUND_TRIP_UNIT(U, LOW, HIGH) \
1271 do { \
1272 for (int64_t i = LOW; i < HIGH; ++i) { \
1273 absl::Duration d = absl::U(i); \
1274 if (d == absl::InfiniteDuration()) \
1275 EXPECT_EQ(kint64max, d / absl::U(1)); \
1276 else if (d == -absl::InfiniteDuration()) \
1277 EXPECT_EQ(kint64min, d / absl::U(1)); \
1278 else \
1279 EXPECT_EQ(i, absl::U(i) / absl::U(1)); \
1280 } \
1281 } while (0)
1282
1283 ROUND_TRIP_UNIT(Nanoseconds, kint64min, kint64min + kRange);
1284 ROUND_TRIP_UNIT(Nanoseconds, -kRange, kRange);
1285 ROUND_TRIP_UNIT(Nanoseconds, kint64max - kRange, kint64max);
1286
1287 ROUND_TRIP_UNIT(Microseconds, kint64min, kint64min + kRange);
1288 ROUND_TRIP_UNIT(Microseconds, -kRange, kRange);
1289 ROUND_TRIP_UNIT(Microseconds, kint64max - kRange, kint64max);
1290
1291 ROUND_TRIP_UNIT(Milliseconds, kint64min, kint64min + kRange);
1292 ROUND_TRIP_UNIT(Milliseconds, -kRange, kRange);
1293 ROUND_TRIP_UNIT(Milliseconds, kint64max - kRange, kint64max);
1294
1295 ROUND_TRIP_UNIT(Seconds, kint64min, kint64min + kRange);
1296 ROUND_TRIP_UNIT(Seconds, -kRange, kRange);
1297 ROUND_TRIP_UNIT(Seconds, kint64max - kRange, kint64max);
1298
1299 ROUND_TRIP_UNIT(Minutes, kint64min / 60, kint64min / 60 + kRange);
1300 ROUND_TRIP_UNIT(Minutes, -kRange, kRange);
1301 ROUND_TRIP_UNIT(Minutes, kint64max / 60 - kRange, kint64max / 60);
1302
1303 ROUND_TRIP_UNIT(Hours, kint64min / 3600, kint64min / 3600 + kRange);
1304 ROUND_TRIP_UNIT(Hours, -kRange, kRange);
1305 ROUND_TRIP_UNIT(Hours, kint64max / 3600 - kRange, kint64max / 3600);
1306
1307 #undef ROUND_TRIP_UNIT
1308 }
1309
TEST(Duration,TruncConversions)1310 TEST(Duration, TruncConversions) {
1311 // Tests ToTimespec()/DurationFromTimespec()
1312 const struct {
1313 absl::Duration d;
1314 timespec ts;
1315 } to_ts[] = {
1316 {absl::Seconds(1) + absl::Nanoseconds(1), {1, 1}},
1317 {absl::Seconds(1) + absl::Nanoseconds(1) / 2, {1, 0}},
1318 {absl::Seconds(1) + absl::Nanoseconds(0), {1, 0}},
1319 {absl::Seconds(0) + absl::Nanoseconds(0), {0, 0}},
1320 {absl::Seconds(0) - absl::Nanoseconds(1) / 2, {0, 0}},
1321 {absl::Seconds(0) - absl::Nanoseconds(1), {-1, 999999999}},
1322 {absl::Seconds(-1) + absl::Nanoseconds(1), {-1, 1}},
1323 {absl::Seconds(-1) + absl::Nanoseconds(1) / 2, {-1, 1}},
1324 {absl::Seconds(-1) + absl::Nanoseconds(0), {-1, 0}},
1325 {absl::Seconds(-1) - absl::Nanoseconds(1) / 2, {-1, 0}},
1326 };
1327 for (const auto& test : to_ts) {
1328 EXPECT_THAT(absl::ToTimespec(test.d), TimespecMatcher(test.ts));
1329 }
1330 const struct {
1331 timespec ts;
1332 absl::Duration d;
1333 } from_ts[] = {
1334 {{1, 1}, absl::Seconds(1) + absl::Nanoseconds(1)},
1335 {{1, 0}, absl::Seconds(1) + absl::Nanoseconds(0)},
1336 {{0, 0}, absl::Seconds(0) + absl::Nanoseconds(0)},
1337 {{0, -1}, absl::Seconds(0) - absl::Nanoseconds(1)},
1338 {{-1, 999999999}, absl::Seconds(0) - absl::Nanoseconds(1)},
1339 {{-1, 1}, absl::Seconds(-1) + absl::Nanoseconds(1)},
1340 {{-1, 0}, absl::Seconds(-1) + absl::Nanoseconds(0)},
1341 {{-1, -1}, absl::Seconds(-1) - absl::Nanoseconds(1)},
1342 {{-2, 999999999}, absl::Seconds(-1) - absl::Nanoseconds(1)},
1343 };
1344 for (const auto& test : from_ts) {
1345 EXPECT_EQ(test.d, absl::DurationFromTimespec(test.ts));
1346 }
1347
1348 // Tests ToTimeval()/DurationFromTimeval() (same as timespec above)
1349 const struct {
1350 absl::Duration d;
1351 timeval tv;
1352 } to_tv[] = {
1353 {absl::Seconds(1) + absl::Microseconds(1), {1, 1}},
1354 {absl::Seconds(1) + absl::Microseconds(1) / 2, {1, 0}},
1355 {absl::Seconds(1) + absl::Microseconds(0), {1, 0}},
1356 {absl::Seconds(0) + absl::Microseconds(0), {0, 0}},
1357 {absl::Seconds(0) - absl::Microseconds(1) / 2, {0, 0}},
1358 {absl::Seconds(0) - absl::Microseconds(1), {-1, 999999}},
1359 {absl::Seconds(-1) + absl::Microseconds(1), {-1, 1}},
1360 {absl::Seconds(-1) + absl::Microseconds(1) / 2, {-1, 1}},
1361 {absl::Seconds(-1) + absl::Microseconds(0), {-1, 0}},
1362 {absl::Seconds(-1) - absl::Microseconds(1) / 2, {-1, 0}},
1363 };
1364 for (const auto& test : to_tv) {
1365 EXPECT_THAT(absl::ToTimeval(test.d), TimevalMatcher(test.tv));
1366 }
1367 const struct {
1368 timeval tv;
1369 absl::Duration d;
1370 } from_tv[] = {
1371 {{1, 1}, absl::Seconds(1) + absl::Microseconds(1)},
1372 {{1, 0}, absl::Seconds(1) + absl::Microseconds(0)},
1373 {{0, 0}, absl::Seconds(0) + absl::Microseconds(0)},
1374 {{0, -1}, absl::Seconds(0) - absl::Microseconds(1)},
1375 {{-1, 999999}, absl::Seconds(0) - absl::Microseconds(1)},
1376 {{-1, 1}, absl::Seconds(-1) + absl::Microseconds(1)},
1377 {{-1, 0}, absl::Seconds(-1) + absl::Microseconds(0)},
1378 {{-1, -1}, absl::Seconds(-1) - absl::Microseconds(1)},
1379 {{-2, 999999}, absl::Seconds(-1) - absl::Microseconds(1)},
1380 };
1381 for (const auto& test : from_tv) {
1382 EXPECT_EQ(test.d, absl::DurationFromTimeval(test.tv));
1383 }
1384 }
1385
TEST(Duration,SmallConversions)1386 TEST(Duration, SmallConversions) {
1387 // Special tests for conversions of small durations.
1388
1389 EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(0));
1390 // TODO(bww): Is the next one OK?
1391 EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(std::nextafter(0.125e-9, 0)));
1392 EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.125e-9));
1393 EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.250e-9));
1394 EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.375e-9));
1395 EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.500e-9));
1396 EXPECT_EQ(absl::Nanoseconds(3) / 4, absl::Seconds(0.625e-9));
1397 EXPECT_EQ(absl::Nanoseconds(3) / 4, absl::Seconds(0.750e-9));
1398 EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(0.875e-9));
1399 EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(1.000e-9));
1400
1401 EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(std::nextafter(-0.125e-9, 0)));
1402 EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.125e-9));
1403 EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.250e-9));
1404 EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.375e-9));
1405 EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.500e-9));
1406 EXPECT_EQ(-absl::Nanoseconds(3) / 4, absl::Seconds(-0.625e-9));
1407 EXPECT_EQ(-absl::Nanoseconds(3) / 4, absl::Seconds(-0.750e-9));
1408 EXPECT_EQ(-absl::Nanoseconds(1), absl::Seconds(-0.875e-9));
1409 EXPECT_EQ(-absl::Nanoseconds(1), absl::Seconds(-1.000e-9));
1410
1411 timespec ts;
1412 ts.tv_sec = 0;
1413 ts.tv_nsec = 0;
1414 EXPECT_THAT(ToTimespec(absl::Nanoseconds(0)), TimespecMatcher(ts));
1415 // TODO(bww): Are the next three OK?
1416 EXPECT_THAT(ToTimespec(absl::Nanoseconds(1) / 4), TimespecMatcher(ts));
1417 EXPECT_THAT(ToTimespec(absl::Nanoseconds(2) / 4), TimespecMatcher(ts));
1418 EXPECT_THAT(ToTimespec(absl::Nanoseconds(3) / 4), TimespecMatcher(ts));
1419 ts.tv_nsec = 1;
1420 EXPECT_THAT(ToTimespec(absl::Nanoseconds(4) / 4), TimespecMatcher(ts));
1421 EXPECT_THAT(ToTimespec(absl::Nanoseconds(5) / 4), TimespecMatcher(ts));
1422 EXPECT_THAT(ToTimespec(absl::Nanoseconds(6) / 4), TimespecMatcher(ts));
1423 EXPECT_THAT(ToTimespec(absl::Nanoseconds(7) / 4), TimespecMatcher(ts));
1424 ts.tv_nsec = 2;
1425 EXPECT_THAT(ToTimespec(absl::Nanoseconds(8) / 4), TimespecMatcher(ts));
1426
1427 timeval tv;
1428 tv.tv_sec = 0;
1429 tv.tv_usec = 0;
1430 EXPECT_THAT(ToTimeval(absl::Nanoseconds(0)), TimevalMatcher(tv));
1431 // TODO(bww): Is the next one OK?
1432 EXPECT_THAT(ToTimeval(absl::Nanoseconds(999)), TimevalMatcher(tv));
1433 tv.tv_usec = 1;
1434 EXPECT_THAT(ToTimeval(absl::Nanoseconds(1000)), TimevalMatcher(tv));
1435 EXPECT_THAT(ToTimeval(absl::Nanoseconds(1999)), TimevalMatcher(tv));
1436 tv.tv_usec = 2;
1437 EXPECT_THAT(ToTimeval(absl::Nanoseconds(2000)), TimevalMatcher(tv));
1438 }
1439
VerifyApproxSameAsMul(double time_as_seconds,int * const misses)1440 void VerifyApproxSameAsMul(double time_as_seconds, int* const misses) {
1441 auto direct_seconds = absl::Seconds(time_as_seconds);
1442 auto mul_by_one_second = time_as_seconds * absl::Seconds(1);
1443 // These are expected to differ by up to one tick due to fused multiply/add
1444 // contraction.
1445 if (absl::AbsDuration(direct_seconds - mul_by_one_second) >
1446 absl::time_internal::MakeDuration(0, 1u)) {
1447 if (*misses > 10) return;
1448 ASSERT_LE(++(*misses), 10) << "Too many errors, not reporting more.";
1449 EXPECT_EQ(direct_seconds, mul_by_one_second)
1450 << "given double time_as_seconds = " << std::setprecision(17)
1451 << time_as_seconds;
1452 }
1453 }
1454
1455 // For a variety of interesting durations, we find the exact point
1456 // where one double converts to that duration, and the very next double
1457 // converts to the next duration. For both of those points, verify that
1458 // Seconds(point) returns a duration near point * Seconds(1.0). (They may
1459 // not be exactly equal due to fused multiply/add contraction.)
TEST(Duration,ToDoubleSecondsCheckEdgeCases)1460 TEST(Duration, ToDoubleSecondsCheckEdgeCases) {
1461 #if (defined(__i386__) || defined(_M_IX86)) && FLT_EVAL_METHOD != 0
1462 // We're using an x87-compatible FPU, and intermediate operations can be
1463 // performed with 80-bit floats. This means the edge cases are different than
1464 // what we expect here, so just skip this test.
1465 GTEST_SKIP()
1466 << "Skipping the test because we detected x87 floating-point semantics";
1467 #endif
1468
1469 constexpr uint32_t kTicksPerSecond = absl::time_internal::kTicksPerSecond;
1470 constexpr auto duration_tick = absl::time_internal::MakeDuration(0, 1u);
1471 int misses = 0;
1472 for (int64_t seconds = 0; seconds < 99; ++seconds) {
1473 uint32_t tick_vals[] = {0, +999, +999999, +999999999, kTicksPerSecond - 1,
1474 0, 1000, 1000000, 1000000000, kTicksPerSecond,
1475 1, 1001, 1000001, 1000000001, kTicksPerSecond + 1,
1476 2, 1002, 1000002, 1000000002, kTicksPerSecond + 2,
1477 3, 1003, 1000003, 1000000003, kTicksPerSecond + 3,
1478 4, 1004, 1000004, 1000000004, kTicksPerSecond + 4,
1479 5, 6, 7, 8, 9};
1480 for (uint32_t ticks : tick_vals) {
1481 absl::Duration s_plus_t = absl::Seconds(seconds) + ticks * duration_tick;
1482 for (absl::Duration d : {s_plus_t, -s_plus_t}) {
1483 absl::Duration after_d = d + duration_tick;
1484 EXPECT_NE(d, after_d);
1485 EXPECT_EQ(after_d - d, duration_tick);
1486
1487 double low_edge = ToDoubleSeconds(d);
1488 EXPECT_EQ(d, absl::Seconds(low_edge));
1489
1490 double high_edge = ToDoubleSeconds(after_d);
1491 EXPECT_EQ(after_d, absl::Seconds(high_edge));
1492
1493 for (;;) {
1494 double midpoint = low_edge + (high_edge - low_edge) / 2;
1495 if (midpoint == low_edge || midpoint == high_edge) break;
1496 absl::Duration mid_duration = absl::Seconds(midpoint);
1497 if (mid_duration == d) {
1498 low_edge = midpoint;
1499 } else {
1500 EXPECT_EQ(mid_duration, after_d);
1501 high_edge = midpoint;
1502 }
1503 }
1504 // Now low_edge is the highest double that converts to Duration d,
1505 // and high_edge is the lowest double that converts to Duration after_d.
1506 VerifyApproxSameAsMul(low_edge, &misses);
1507 VerifyApproxSameAsMul(high_edge, &misses);
1508 }
1509 }
1510 }
1511 }
1512
TEST(Duration,ToDoubleSecondsCheckRandom)1513 TEST(Duration, ToDoubleSecondsCheckRandom) {
1514 std::random_device rd;
1515 std::seed_seq seed({rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()});
1516 std::mt19937_64 gen(seed);
1517 // We want doubles distributed from 1/8ns up to 2^63, where
1518 // as many values are tested from 1ns to 2ns as from 1sec to 2sec,
1519 // so even distribute along a log-scale of those values, and
1520 // exponentiate before using them. (9.223377e+18 is just slightly
1521 // out of bounds for absl::Duration.)
1522 std::uniform_real_distribution<double> uniform(std::log(0.125e-9),
1523 std::log(9.223377e+18));
1524 int misses = 0;
1525 for (int i = 0; i < 1000000; ++i) {
1526 double d = std::exp(uniform(gen));
1527 VerifyApproxSameAsMul(d, &misses);
1528 VerifyApproxSameAsMul(-d, &misses);
1529 }
1530 }
1531
TEST(Duration,ConversionSaturation)1532 TEST(Duration, ConversionSaturation) {
1533 absl::Duration d;
1534
1535 const auto max_timeval_sec =
1536 std::numeric_limits<decltype(timeval::tv_sec)>::max();
1537 const auto min_timeval_sec =
1538 std::numeric_limits<decltype(timeval::tv_sec)>::min();
1539 timeval tv;
1540 tv.tv_sec = max_timeval_sec;
1541 tv.tv_usec = 999998;
1542 d = absl::DurationFromTimeval(tv);
1543 tv = ToTimeval(d);
1544 EXPECT_EQ(max_timeval_sec, tv.tv_sec);
1545 EXPECT_EQ(999998, tv.tv_usec);
1546 d += absl::Microseconds(1);
1547 tv = ToTimeval(d);
1548 EXPECT_EQ(max_timeval_sec, tv.tv_sec);
1549 EXPECT_EQ(999999, tv.tv_usec);
1550 d += absl::Microseconds(1); // no effect
1551 tv = ToTimeval(d);
1552 EXPECT_EQ(max_timeval_sec, tv.tv_sec);
1553 EXPECT_EQ(999999, tv.tv_usec);
1554
1555 tv.tv_sec = min_timeval_sec;
1556 tv.tv_usec = 1;
1557 d = absl::DurationFromTimeval(tv);
1558 tv = ToTimeval(d);
1559 EXPECT_EQ(min_timeval_sec, tv.tv_sec);
1560 EXPECT_EQ(1, tv.tv_usec);
1561 d -= absl::Microseconds(1);
1562 tv = ToTimeval(d);
1563 EXPECT_EQ(min_timeval_sec, tv.tv_sec);
1564 EXPECT_EQ(0, tv.tv_usec);
1565 d -= absl::Microseconds(1); // no effect
1566 tv = ToTimeval(d);
1567 EXPECT_EQ(min_timeval_sec, tv.tv_sec);
1568 EXPECT_EQ(0, tv.tv_usec);
1569
1570 const auto max_timespec_sec =
1571 std::numeric_limits<decltype(timespec::tv_sec)>::max();
1572 const auto min_timespec_sec =
1573 std::numeric_limits<decltype(timespec::tv_sec)>::min();
1574 timespec ts;
1575 ts.tv_sec = max_timespec_sec;
1576 ts.tv_nsec = 999999998;
1577 d = absl::DurationFromTimespec(ts);
1578 ts = absl::ToTimespec(d);
1579 EXPECT_EQ(max_timespec_sec, ts.tv_sec);
1580 EXPECT_EQ(999999998, ts.tv_nsec);
1581 d += absl::Nanoseconds(1);
1582 ts = absl::ToTimespec(d);
1583 EXPECT_EQ(max_timespec_sec, ts.tv_sec);
1584 EXPECT_EQ(999999999, ts.tv_nsec);
1585 d += absl::Nanoseconds(1); // no effect
1586 ts = absl::ToTimespec(d);
1587 EXPECT_EQ(max_timespec_sec, ts.tv_sec);
1588 EXPECT_EQ(999999999, ts.tv_nsec);
1589
1590 ts.tv_sec = min_timespec_sec;
1591 ts.tv_nsec = 1;
1592 d = absl::DurationFromTimespec(ts);
1593 ts = absl::ToTimespec(d);
1594 EXPECT_EQ(min_timespec_sec, ts.tv_sec);
1595 EXPECT_EQ(1, ts.tv_nsec);
1596 d -= absl::Nanoseconds(1);
1597 ts = absl::ToTimespec(d);
1598 EXPECT_EQ(min_timespec_sec, ts.tv_sec);
1599 EXPECT_EQ(0, ts.tv_nsec);
1600 d -= absl::Nanoseconds(1); // no effect
1601 ts = absl::ToTimespec(d);
1602 EXPECT_EQ(min_timespec_sec, ts.tv_sec);
1603 EXPECT_EQ(0, ts.tv_nsec);
1604 }
1605
TEST(Duration,FormatDuration)1606 TEST(Duration, FormatDuration) {
1607 // Example from Go's docs.
1608 EXPECT_EQ("72h3m0.5s",
1609 absl::FormatDuration(absl::Hours(72) + absl::Minutes(3) +
1610 absl::Milliseconds(500)));
1611 // Go's largest time: 2540400h10m10.000000000s
1612 EXPECT_EQ("2540400h10m10s",
1613 absl::FormatDuration(absl::Hours(2540400) + absl::Minutes(10) +
1614 absl::Seconds(10)));
1615
1616 EXPECT_EQ("0", absl::FormatDuration(absl::ZeroDuration()));
1617 EXPECT_EQ("0", absl::FormatDuration(absl::Seconds(0)));
1618 EXPECT_EQ("0", absl::FormatDuration(absl::Nanoseconds(0)));
1619
1620 EXPECT_EQ("1ns", absl::FormatDuration(absl::Nanoseconds(1)));
1621 EXPECT_EQ("1us", absl::FormatDuration(absl::Microseconds(1)));
1622 EXPECT_EQ("1ms", absl::FormatDuration(absl::Milliseconds(1)));
1623 EXPECT_EQ("1s", absl::FormatDuration(absl::Seconds(1)));
1624 EXPECT_EQ("1m", absl::FormatDuration(absl::Minutes(1)));
1625 EXPECT_EQ("1h", absl::FormatDuration(absl::Hours(1)));
1626
1627 EXPECT_EQ("1h1m", absl::FormatDuration(absl::Hours(1) + absl::Minutes(1)));
1628 EXPECT_EQ("1h1s", absl::FormatDuration(absl::Hours(1) + absl::Seconds(1)));
1629 EXPECT_EQ("1m1s", absl::FormatDuration(absl::Minutes(1) + absl::Seconds(1)));
1630
1631 EXPECT_EQ("1h0.25s",
1632 absl::FormatDuration(absl::Hours(1) + absl::Milliseconds(250)));
1633 EXPECT_EQ("1m0.25s",
1634 absl::FormatDuration(absl::Minutes(1) + absl::Milliseconds(250)));
1635 EXPECT_EQ("1h1m0.25s",
1636 absl::FormatDuration(absl::Hours(1) + absl::Minutes(1) +
1637 absl::Milliseconds(250)));
1638 EXPECT_EQ("1h0.0005s",
1639 absl::FormatDuration(absl::Hours(1) + absl::Microseconds(500)));
1640 EXPECT_EQ("1h0.0000005s",
1641 absl::FormatDuration(absl::Hours(1) + absl::Nanoseconds(500)));
1642
1643 // Subsecond special case.
1644 EXPECT_EQ("1.5ns", absl::FormatDuration(absl::Nanoseconds(1) +
1645 absl::Nanoseconds(1) / 2));
1646 EXPECT_EQ("1.25ns", absl::FormatDuration(absl::Nanoseconds(1) +
1647 absl::Nanoseconds(1) / 4));
1648 EXPECT_EQ("1ns", absl::FormatDuration(absl::Nanoseconds(1) +
1649 absl::Nanoseconds(1) / 9));
1650 EXPECT_EQ("1.2us", absl::FormatDuration(absl::Microseconds(1) +
1651 absl::Nanoseconds(200)));
1652 EXPECT_EQ("1.2ms", absl::FormatDuration(absl::Milliseconds(1) +
1653 absl::Microseconds(200)));
1654 EXPECT_EQ("1.0002ms", absl::FormatDuration(absl::Milliseconds(1) +
1655 absl::Nanoseconds(200)));
1656 EXPECT_EQ("1.00001ms", absl::FormatDuration(absl::Milliseconds(1) +
1657 absl::Nanoseconds(10)));
1658 EXPECT_EQ("1.000001ms",
1659 absl::FormatDuration(absl::Milliseconds(1) + absl::Nanoseconds(1)));
1660
1661 // Negative durations.
1662 EXPECT_EQ("-1ns", absl::FormatDuration(absl::Nanoseconds(-1)));
1663 EXPECT_EQ("-1us", absl::FormatDuration(absl::Microseconds(-1)));
1664 EXPECT_EQ("-1ms", absl::FormatDuration(absl::Milliseconds(-1)));
1665 EXPECT_EQ("-1s", absl::FormatDuration(absl::Seconds(-1)));
1666 EXPECT_EQ("-1m", absl::FormatDuration(absl::Minutes(-1)));
1667 EXPECT_EQ("-1h", absl::FormatDuration(absl::Hours(-1)));
1668
1669 EXPECT_EQ("-1h1m",
1670 absl::FormatDuration(-(absl::Hours(1) + absl::Minutes(1))));
1671 EXPECT_EQ("-1h1s",
1672 absl::FormatDuration(-(absl::Hours(1) + absl::Seconds(1))));
1673 EXPECT_EQ("-1m1s",
1674 absl::FormatDuration(-(absl::Minutes(1) + absl::Seconds(1))));
1675
1676 EXPECT_EQ("-1ns", absl::FormatDuration(absl::Nanoseconds(-1)));
1677 EXPECT_EQ("-1.2us", absl::FormatDuration(
1678 -(absl::Microseconds(1) + absl::Nanoseconds(200))));
1679 EXPECT_EQ("-1.2ms", absl::FormatDuration(
1680 -(absl::Milliseconds(1) + absl::Microseconds(200))));
1681 EXPECT_EQ("-1.0002ms", absl::FormatDuration(-(absl::Milliseconds(1) +
1682 absl::Nanoseconds(200))));
1683 EXPECT_EQ("-1.00001ms", absl::FormatDuration(-(absl::Milliseconds(1) +
1684 absl::Nanoseconds(10))));
1685 EXPECT_EQ("-1.000001ms", absl::FormatDuration(-(absl::Milliseconds(1) +
1686 absl::Nanoseconds(1))));
1687
1688 //
1689 // Interesting corner cases.
1690 //
1691
1692 const absl::Duration qns = absl::Nanoseconds(1) / 4;
1693 const absl::Duration max_dur =
1694 absl::Seconds(kint64max) + (absl::Seconds(1) - qns);
1695 const absl::Duration min_dur = absl::Seconds(kint64min);
1696
1697 EXPECT_EQ("0.25ns", absl::FormatDuration(qns));
1698 EXPECT_EQ("-0.25ns", absl::FormatDuration(-qns));
1699 EXPECT_EQ("2562047788015215h30m7.99999999975s",
1700 absl::FormatDuration(max_dur));
1701 EXPECT_EQ("-2562047788015215h30m8s", absl::FormatDuration(min_dur));
1702
1703 // Tests printing full precision from units that print using FDivDuration
1704 EXPECT_EQ("55.00000000025s", absl::FormatDuration(absl::Seconds(55) + qns));
1705 EXPECT_EQ("55.00000025ms",
1706 absl::FormatDuration(absl::Milliseconds(55) + qns));
1707 EXPECT_EQ("55.00025us", absl::FormatDuration(absl::Microseconds(55) + qns));
1708 EXPECT_EQ("55.25ns", absl::FormatDuration(absl::Nanoseconds(55) + qns));
1709
1710 // Formatting infinity
1711 EXPECT_EQ("inf", absl::FormatDuration(absl::InfiniteDuration()));
1712 EXPECT_EQ("-inf", absl::FormatDuration(-absl::InfiniteDuration()));
1713
1714 // Formatting approximately +/- 100 billion years
1715 const absl::Duration huge_range = ApproxYears(100000000000);
1716 EXPECT_EQ("876000000000000h", absl::FormatDuration(huge_range));
1717 EXPECT_EQ("-876000000000000h", absl::FormatDuration(-huge_range));
1718
1719 EXPECT_EQ("876000000000000h0.999999999s",
1720 absl::FormatDuration(huge_range +
1721 (absl::Seconds(1) - absl::Nanoseconds(1))));
1722 EXPECT_EQ("876000000000000h0.9999999995s",
1723 absl::FormatDuration(
1724 huge_range + (absl::Seconds(1) - absl::Nanoseconds(1) / 2)));
1725 EXPECT_EQ("876000000000000h0.99999999975s",
1726 absl::FormatDuration(
1727 huge_range + (absl::Seconds(1) - absl::Nanoseconds(1) / 4)));
1728
1729 EXPECT_EQ("-876000000000000h0.999999999s",
1730 absl::FormatDuration(-huge_range -
1731 (absl::Seconds(1) - absl::Nanoseconds(1))));
1732 EXPECT_EQ("-876000000000000h0.9999999995s",
1733 absl::FormatDuration(
1734 -huge_range - (absl::Seconds(1) - absl::Nanoseconds(1) / 2)));
1735 EXPECT_EQ("-876000000000000h0.99999999975s",
1736 absl::FormatDuration(
1737 -huge_range - (absl::Seconds(1) - absl::Nanoseconds(1) / 4)));
1738 }
1739
TEST(Duration,ParseDuration)1740 TEST(Duration, ParseDuration) {
1741 absl::Duration d;
1742
1743 // No specified unit. Should only work for zero and infinity.
1744 EXPECT_TRUE(absl::ParseDuration("0", &d));
1745 EXPECT_EQ(absl::ZeroDuration(), d);
1746 EXPECT_TRUE(absl::ParseDuration("+0", &d));
1747 EXPECT_EQ(absl::ZeroDuration(), d);
1748 EXPECT_TRUE(absl::ParseDuration("-0", &d));
1749 EXPECT_EQ(absl::ZeroDuration(), d);
1750
1751 EXPECT_TRUE(absl::ParseDuration("inf", &d));
1752 EXPECT_EQ(absl::InfiniteDuration(), d);
1753 EXPECT_TRUE(absl::ParseDuration("+inf", &d));
1754 EXPECT_EQ(absl::InfiniteDuration(), d);
1755 EXPECT_TRUE(absl::ParseDuration("-inf", &d));
1756 EXPECT_EQ(-absl::InfiniteDuration(), d);
1757 EXPECT_FALSE(absl::ParseDuration("infBlah", &d));
1758
1759 // Illegal input forms.
1760 EXPECT_FALSE(absl::ParseDuration("", &d));
1761 EXPECT_FALSE(absl::ParseDuration("0.0", &d));
1762 EXPECT_FALSE(absl::ParseDuration(".0", &d));
1763 EXPECT_FALSE(absl::ParseDuration(".", &d));
1764 EXPECT_FALSE(absl::ParseDuration("01", &d));
1765 EXPECT_FALSE(absl::ParseDuration("1", &d));
1766 EXPECT_FALSE(absl::ParseDuration("-1", &d));
1767 EXPECT_FALSE(absl::ParseDuration("2", &d));
1768 EXPECT_FALSE(absl::ParseDuration("2 s", &d));
1769 EXPECT_FALSE(absl::ParseDuration(".s", &d));
1770 EXPECT_FALSE(absl::ParseDuration("-.s", &d));
1771 EXPECT_FALSE(absl::ParseDuration("s", &d));
1772 EXPECT_FALSE(absl::ParseDuration(" 2s", &d));
1773 EXPECT_FALSE(absl::ParseDuration("2s ", &d));
1774 EXPECT_FALSE(absl::ParseDuration(" 2s ", &d));
1775 EXPECT_FALSE(absl::ParseDuration("2mt", &d));
1776 EXPECT_FALSE(absl::ParseDuration("1e3s", &d));
1777
1778 // One unit type.
1779 EXPECT_TRUE(absl::ParseDuration("1ns", &d));
1780 EXPECT_EQ(absl::Nanoseconds(1), d);
1781 EXPECT_TRUE(absl::ParseDuration("1us", &d));
1782 EXPECT_EQ(absl::Microseconds(1), d);
1783 EXPECT_TRUE(absl::ParseDuration("1ms", &d));
1784 EXPECT_EQ(absl::Milliseconds(1), d);
1785 EXPECT_TRUE(absl::ParseDuration("1s", &d));
1786 EXPECT_EQ(absl::Seconds(1), d);
1787 EXPECT_TRUE(absl::ParseDuration("2m", &d));
1788 EXPECT_EQ(absl::Minutes(2), d);
1789 EXPECT_TRUE(absl::ParseDuration("2h", &d));
1790 EXPECT_EQ(absl::Hours(2), d);
1791
1792 // Huge counts of a unit.
1793 EXPECT_TRUE(absl::ParseDuration("9223372036854775807us", &d));
1794 EXPECT_EQ(absl::Microseconds(9223372036854775807), d);
1795 EXPECT_TRUE(absl::ParseDuration("-9223372036854775807us", &d));
1796 EXPECT_EQ(absl::Microseconds(-9223372036854775807), d);
1797
1798 // Multiple units.
1799 EXPECT_TRUE(absl::ParseDuration("2h3m4s", &d));
1800 EXPECT_EQ(absl::Hours(2) + absl::Minutes(3) + absl::Seconds(4), d);
1801 EXPECT_TRUE(absl::ParseDuration("3m4s5us", &d));
1802 EXPECT_EQ(absl::Minutes(3) + absl::Seconds(4) + absl::Microseconds(5), d);
1803 EXPECT_TRUE(absl::ParseDuration("2h3m4s5ms6us7ns", &d));
1804 EXPECT_EQ(absl::Hours(2) + absl::Minutes(3) + absl::Seconds(4) +
1805 absl::Milliseconds(5) + absl::Microseconds(6) +
1806 absl::Nanoseconds(7),
1807 d);
1808
1809 // Multiple units out of order.
1810 EXPECT_TRUE(absl::ParseDuration("2us3m4s5h", &d));
1811 EXPECT_EQ(absl::Hours(5) + absl::Minutes(3) + absl::Seconds(4) +
1812 absl::Microseconds(2),
1813 d);
1814
1815 // Fractional values of units.
1816 EXPECT_TRUE(absl::ParseDuration("1.5ns", &d));
1817 EXPECT_EQ(1.5 * absl::Nanoseconds(1), d);
1818 EXPECT_TRUE(absl::ParseDuration("1.5us", &d));
1819 EXPECT_EQ(1.5 * absl::Microseconds(1), d);
1820 EXPECT_TRUE(absl::ParseDuration("1.5ms", &d));
1821 EXPECT_EQ(1.5 * absl::Milliseconds(1), d);
1822 EXPECT_TRUE(absl::ParseDuration("1.5s", &d));
1823 EXPECT_EQ(1.5 * absl::Seconds(1), d);
1824 EXPECT_TRUE(absl::ParseDuration("1.5m", &d));
1825 EXPECT_EQ(1.5 * absl::Minutes(1), d);
1826 EXPECT_TRUE(absl::ParseDuration("1.5h", &d));
1827 EXPECT_EQ(1.5 * absl::Hours(1), d);
1828
1829 // Huge fractional counts of a unit.
1830 EXPECT_TRUE(absl::ParseDuration("0.4294967295s", &d));
1831 EXPECT_EQ(absl::Nanoseconds(429496729) + absl::Nanoseconds(1) / 2, d);
1832 EXPECT_TRUE(absl::ParseDuration("0.429496729501234567890123456789s", &d));
1833 EXPECT_EQ(absl::Nanoseconds(429496729) + absl::Nanoseconds(1) / 2, d);
1834
1835 // Negative durations.
1836 EXPECT_TRUE(absl::ParseDuration("-1s", &d));
1837 EXPECT_EQ(absl::Seconds(-1), d);
1838 EXPECT_TRUE(absl::ParseDuration("-1m", &d));
1839 EXPECT_EQ(absl::Minutes(-1), d);
1840 EXPECT_TRUE(absl::ParseDuration("-1h", &d));
1841 EXPECT_EQ(absl::Hours(-1), d);
1842
1843 EXPECT_TRUE(absl::ParseDuration("-1h2s", &d));
1844 EXPECT_EQ(-(absl::Hours(1) + absl::Seconds(2)), d);
1845 EXPECT_FALSE(absl::ParseDuration("1h-2s", &d));
1846 EXPECT_FALSE(absl::ParseDuration("-1h-2s", &d));
1847 EXPECT_FALSE(absl::ParseDuration("-1h -2s", &d));
1848 }
1849
TEST(Duration,FormatParseRoundTrip)1850 TEST(Duration, FormatParseRoundTrip) {
1851 #define TEST_PARSE_ROUNDTRIP(d) \
1852 do { \
1853 std::string s = absl::FormatDuration(d); \
1854 absl::Duration dur; \
1855 EXPECT_TRUE(absl::ParseDuration(s, &dur)); \
1856 EXPECT_EQ(d, dur); \
1857 } while (0)
1858
1859 TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(1));
1860 TEST_PARSE_ROUNDTRIP(absl::Microseconds(1));
1861 TEST_PARSE_ROUNDTRIP(absl::Milliseconds(1));
1862 TEST_PARSE_ROUNDTRIP(absl::Seconds(1));
1863 TEST_PARSE_ROUNDTRIP(absl::Minutes(1));
1864 TEST_PARSE_ROUNDTRIP(absl::Hours(1));
1865 TEST_PARSE_ROUNDTRIP(absl::Hours(1) + absl::Nanoseconds(2));
1866
1867 TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(-1));
1868 TEST_PARSE_ROUNDTRIP(absl::Microseconds(-1));
1869 TEST_PARSE_ROUNDTRIP(absl::Milliseconds(-1));
1870 TEST_PARSE_ROUNDTRIP(absl::Seconds(-1));
1871 TEST_PARSE_ROUNDTRIP(absl::Minutes(-1));
1872 TEST_PARSE_ROUNDTRIP(absl::Hours(-1));
1873
1874 TEST_PARSE_ROUNDTRIP(absl::Hours(-1) + absl::Nanoseconds(2));
1875 TEST_PARSE_ROUNDTRIP(absl::Hours(1) + absl::Nanoseconds(-2));
1876 TEST_PARSE_ROUNDTRIP(absl::Hours(-1) + absl::Nanoseconds(-2));
1877
1878 TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(1) +
1879 absl::Nanoseconds(1) / 4); // 1.25ns
1880
1881 const absl::Duration huge_range = ApproxYears(100000000000);
1882 TEST_PARSE_ROUNDTRIP(huge_range);
1883 TEST_PARSE_ROUNDTRIP(huge_range + (absl::Seconds(1) - absl::Nanoseconds(1)));
1884
1885 #undef TEST_PARSE_ROUNDTRIP
1886 }
1887
TEST(Duration,AbslStringify)1888 TEST(Duration, AbslStringify) {
1889 // FormatDuration is already well tested, so just use one test case here to
1890 // verify that StrFormat("%v", d) works as expected.
1891 absl::Duration d = absl::Seconds(1);
1892 EXPECT_EQ(absl::StrFormat("%v", d), absl::FormatDuration(d));
1893 }
1894
TEST(Duration,NoPadding)1895 TEST(Duration, NoPadding) {
1896 // Should match the size of a struct with uint32_t alignment and no padding.
1897 using NoPadding = std::array<uint32_t, 3>;
1898 EXPECT_EQ(sizeof(NoPadding), sizeof(absl::Duration));
1899 EXPECT_EQ(alignof(NoPadding), alignof(absl::Duration));
1900 }
1901
1902 } // namespace
1903