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