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