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