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