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