Skip to content

GitLab

T
tangled
Commit d4ce5f78 authored by Gabriel Charette's avatar Gabriel Charette Committed by Commit Bot
Browse files
Options

constexpr simple TimeDelta methods. 

(removed constexpr for In*() methods found in earlier patch sets
as the inlining incurred too big of a code size increase)

Bug: 761570
Change-Id: Iced714ec5541fa67fcafe0c0dbbc56c9353418c1
Reviewed-on: https://chromium-review.googlesource.com/883126Reviewed-by: default avatarDaniel Cheng <dcheng@chromium.org>
Reviewed-by: default avatarYuri Wiitala <miu@chromium.org>
Commit-Queue: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532884}
parent e34f3cb3
Hide whitespace changes
Inline Side-by-side
Showing with 220 additions and 166 deletions
base/time/time.h
View file @ d4ce5f78
...@@ -132,7 +132,9 @@ class BASE_EXPORT TimeDelta { ...@@ -132,7 +132,9 @@ class BASE_EXPORT TimeDelta {
// may be unclear from the perspective of a caller. // may be unclear from the perspective of a caller.
// //
// DEPRECATED - Do not use in new code. http://crbug.com/634507 // DEPRECATED - Do not use in new code. http://crbug.com/634507
static TimeDelta FromInternalValue(int64_t delta) { return TimeDelta(delta); } static constexpr TimeDelta FromInternalValue(int64_t delta) {
return TimeDelta(delta);
}
// Returns the maximum time delta, which should be greater than any reasonable // Returns the maximum time delta, which should be greater than any reasonable
// time delta we might compare it to. Adding or subtracting the maximum time // time delta we might compare it to. Adding or subtracting the maximum time
...@@ -150,10 +152,10 @@ class BASE_EXPORT TimeDelta { ...@@ -150,10 +152,10 @@ class BASE_EXPORT TimeDelta {
// For serializing, use FromInternalValue to reconstitute. // For serializing, use FromInternalValue to reconstitute.
// //
// DEPRECATED - Do not use in new code. http://crbug.com/634507 // DEPRECATED - Do not use in new code. http://crbug.com/634507
int64_t ToInternalValue() const { return delta_; } constexpr int64_t ToInternalValue() const { return delta_; }
// Returns the magnitude (absolute value) of this TimeDelta. // Returns the magnitude (absolute value) of this TimeDelta.
TimeDelta magnitude() const { constexpr TimeDelta magnitude() const {
// Some toolchains provide an incomplete C++11 implementation and lack an // Some toolchains provide an incomplete C++11 implementation and lack an
// int64_t overload for std::abs(). The following is a simple branchless // int64_t overload for std::abs(). The following is a simple branchless
// implementation: // implementation:
...@@ -162,13 +164,15 @@ class BASE_EXPORT TimeDelta { ...@@ -162,13 +164,15 @@ class BASE_EXPORT TimeDelta {
} }
// Returns true if the time delta is zero. // Returns true if the time delta is zero.
bool is_zero() const { constexpr bool is_zero() const { return delta_ == 0; }
return delta_ == 0;
}
// Returns true if the time delta is the maximum/minimum time delta. // Returns true if the time delta is the maximum/minimum time delta.
bool is_max() const { return delta_ == std::numeric_limits<int64_t>::max(); } constexpr bool is_max() const {
bool is_min() const { return delta_ == std::numeric_limits<int64_t>::min(); } return delta_ == std::numeric_limits<int64_t>::max();
}
constexpr bool is_min() const {
return delta_ == std::numeric_limits<int64_t>::min();
}
#if defined(OS_POSIX) #if defined(OS_POSIX)
struct timespec ToTimeSpec() const; struct timespec ToTimeSpec() const;
...@@ -190,12 +194,15 @@ class BASE_EXPORT TimeDelta { ...@@ -190,12 +194,15 @@ class BASE_EXPORT TimeDelta {
int64_t InMicroseconds() const; int64_t InMicroseconds() const;
int64_t InNanoseconds() const; int64_t InNanoseconds() const;
TimeDelta& operator=(TimeDelta other) { constexpr TimeDelta& operator=(TimeDelta other) {
delta_ = other.delta_; delta_ = other.delta_;
return *this; return *this;
} }
// Computations with other deltas. // Computations with other deltas. Can easily be made constexpr with C++17 but
// hard to do until then per limitations around
// __builtin_(add|sub)_overflow in safe_math_clang_gcc_impl.h :
// https://chromium-review.googlesource.com/c/chromium/src/+/873352#message-59594ab70827795a67e0780404adf37b4b6c2f14
TimeDelta operator+(TimeDelta other) const { TimeDelta operator+(TimeDelta other) const {
return TimeDelta(time_internal::SaturatedAdd(*this, other.delta_)); return TimeDelta(time_internal::SaturatedAdd(*this, other.delta_));
} }
...@@ -209,12 +216,10 @@ class BASE_EXPORT TimeDelta { ...@@ -209,12 +216,10 @@ class BASE_EXPORT TimeDelta {
TimeDelta& operator-=(TimeDelta other) { TimeDelta& operator-=(TimeDelta other) {
return *this = (*this - other); return *this = (*this - other);
} }
TimeDelta operator-() const { constexpr TimeDelta operator-() const { return TimeDelta(-delta_); }
return TimeDelta(-delta_);
}
// Computations with numeric types. // Computations with numeric types.
template<typename T> template <typename T>
TimeDelta operator*(T a) const { TimeDelta operator*(T a) const {
CheckedNumeric<int64_t> rv(delta_); CheckedNumeric<int64_t> rv(delta_);
rv *= a; rv *= a;
...@@ -225,7 +230,7 @@ class BASE_EXPORT TimeDelta { ...@@ -225,7 +230,7 @@ class BASE_EXPORT TimeDelta {
return TimeDelta(std::numeric_limits<int64_t>::min()); return TimeDelta(std::numeric_limits<int64_t>::min());
return TimeDelta(std::numeric_limits<int64_t>::max()); return TimeDelta(std::numeric_limits<int64_t>::max());
} }
template<typename T> template <typename T>
TimeDelta operator/(T a) const { TimeDelta operator/(T a) const {
CheckedNumeric<int64_t> rv(delta_); CheckedNumeric<int64_t> rv(delta_);
rv /= a; rv /= a;
...@@ -237,17 +242,17 @@ class BASE_EXPORT TimeDelta { ...@@ -237,17 +242,17 @@ class BASE_EXPORT TimeDelta {
return TimeDelta(std::numeric_limits<int64_t>::min()); return TimeDelta(std::numeric_limits<int64_t>::min());
return TimeDelta(std::numeric_limits<int64_t>::max()); return TimeDelta(std::numeric_limits<int64_t>::max());
} }
template<typename T> template <typename T>
TimeDelta& operator*=(T a) { TimeDelta& operator*=(T a) {
return *this = (*this * a); return *this = (*this * a);
} }
template<typename T> template <typename T>
TimeDelta& operator/=(T a) { TimeDelta& operator/=(T a) {
return *this = (*this / a); return *this = (*this / a);
} }
int64_t operator/(TimeDelta a) const { return delta_ / a.delta_; } constexpr int64_t operator/(TimeDelta a) const { return delta_ / a.delta_; }
TimeDelta operator%(TimeDelta a) const { constexpr TimeDelta operator%(TimeDelta a) const {
return TimeDelta(delta_ % a.delta_); return TimeDelta(delta_ % a.delta_);
} }
...@@ -296,8 +301,8 @@ class BASE_EXPORT TimeDelta { ...@@ -296,8 +301,8 @@ class BASE_EXPORT TimeDelta {
int64_t delta_; int64_t delta_;
}; };
template<typename T> template <typename T>
inline TimeDelta operator*(T a, TimeDelta td) { TimeDelta operator*(T a, TimeDelta td) {
return td * a; return td * a;
} }
......
base/time/time_unittest.cc
View file @ d4ce5f78
...@@ -1112,19 +1112,19 @@ TEST(TimeDelta, FromAndIn) { ...@@ -1112,19 +1112,19 @@ TEST(TimeDelta, FromAndIn) {
static_assert( static_assert(
TimeDelta::FromMillisecondsD(2.5) == TimeDelta::FromMicroseconds(2500), TimeDelta::FromMillisecondsD(2.5) == TimeDelta::FromMicroseconds(2500),
""); "");
EXPECT_EQ(13, TimeDelta::FromDays(13).InDays()); EXPECT_EQ(TimeDelta::FromDays(13).InDays(), 13);
EXPECT_EQ(13, TimeDelta::FromHours(13).InHours()); EXPECT_EQ(TimeDelta::FromHours(13).InHours(), 13);
EXPECT_EQ(13, TimeDelta::FromMinutes(13).InMinutes()); EXPECT_EQ(TimeDelta::FromMinutes(13).InMinutes(), 13);
EXPECT_EQ(13, TimeDelta::FromSeconds(13).InSeconds()); EXPECT_EQ(TimeDelta::FromSeconds(13).InSeconds(), 13);
EXPECT_EQ(13.0, TimeDelta::FromSeconds(13).InSecondsF()); EXPECT_EQ(TimeDelta::FromSeconds(13).InSecondsF(), 13.0);
EXPECT_EQ(13, TimeDelta::FromMilliseconds(13).InMilliseconds()); EXPECT_EQ(TimeDelta::FromMilliseconds(13).InMilliseconds(), 13);
EXPECT_EQ(13.0, TimeDelta::FromMilliseconds(13).InMillisecondsF()); EXPECT_EQ(TimeDelta::FromMilliseconds(13).InMillisecondsF(), 13.0);
EXPECT_EQ(13, TimeDelta::FromSecondsD(13.1).InSeconds()); EXPECT_EQ(TimeDelta::FromSecondsD(13.1).InSeconds(), 13);
EXPECT_EQ(13.1, TimeDelta::FromSecondsD(13.1).InSecondsF()); EXPECT_EQ(TimeDelta::FromSecondsD(13.1).InSecondsF(), 13.1);
EXPECT_EQ(13, TimeDelta::FromMillisecondsD(13.3).InMilliseconds()); EXPECT_EQ(TimeDelta::FromMillisecondsD(13.3).InMilliseconds(), 13);
EXPECT_EQ(13.3, TimeDelta::FromMillisecondsD(13.3).InMillisecondsF()); EXPECT_EQ(TimeDelta::FromMillisecondsD(13.3).InMillisecondsF(), 13.3);
EXPECT_EQ(13, TimeDelta::FromMicroseconds(13).InMicroseconds()); EXPECT_EQ(TimeDelta::FromMicroseconds(13).InMicroseconds(), 13);
EXPECT_EQ(3.456, TimeDelta::FromMillisecondsD(3.45678).InMillisecondsF()); EXPECT_EQ(TimeDelta::FromMillisecondsD(3.45678).InMillisecondsF(), 3.456);
} }
#if defined(OS_POSIX) #if defined(OS_POSIX)
...@@ -1187,196 +1187,245 @@ std::string AnyToString(Any any) { ...@@ -1187,196 +1187,245 @@ std::string AnyToString(Any any) {
} }
TEST(TimeDelta, Magnitude) { TEST(TimeDelta, Magnitude) {
const int64_t zero = 0; constexpr int64_t zero = 0;
EXPECT_EQ(TimeDelta::FromMicroseconds(zero), static_assert(TimeDelta::FromMicroseconds(zero) ==
TimeDelta::FromMicroseconds(zero).magnitude()); TimeDelta::FromMicroseconds(zero).magnitude(),
"");
const int64_t one = 1;
const int64_t negative_one = -1; constexpr int64_t one = 1;
EXPECT_EQ(TimeDelta::FromMicroseconds(one), constexpr int64_t negative_one = -1;
TimeDelta::FromMicroseconds(one).magnitude()); static_assert(TimeDelta::FromMicroseconds(one) ==
EXPECT_EQ(TimeDelta::FromMicroseconds(one), TimeDelta::FromMicroseconds(one).magnitude(),
TimeDelta::FromMicroseconds(negative_one).magnitude()); "");
static_assert(TimeDelta::FromMicroseconds(one) ==
const int64_t max_int64_minus_one = std::numeric_limits<int64_t>::max() - 1; TimeDelta::FromMicroseconds(negative_one).magnitude(),
const int64_t min_int64_plus_two = std::numeric_limits<int64_t>::min() + 2; "");
EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude()); constexpr int64_t max_int64_minus_one =
EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one), std::numeric_limits<int64_t>::max() - 1;
TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude()); constexpr int64_t min_int64_plus_two =
} std::numeric_limits<int64_t>::min() + 2;
static_assert(
TEST(TimeDelta, Max) { TimeDelta::FromMicroseconds(max_int64_minus_one) ==
TimeDelta max = TimeDelta::Max(); TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude(),
EXPECT_TRUE(max.is_max()); "");
EXPECT_EQ(max, TimeDelta::Max()); static_assert(TimeDelta::FromMicroseconds(max_int64_minus_one) ==
EXPECT_GT(max, TimeDelta::FromDays(100 * 365)); TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude(),
EXPECT_GT(max, TimeDelta()); "");
}
TEST(TimeDelta, ZeroMinMax) {
constexpr TimeDelta kZero;
static_assert(kZero.is_zero(), "");
constexpr TimeDelta kMax = TimeDelta::Max();
static_assert(kMax.is_max(), "");
static_assert(kMax == TimeDelta::Max(), "");
static_assert(kMax > TimeDelta::FromDays(100 * 365), "");
static_assert(kMax > kZero, "");
constexpr TimeDelta kMin = TimeDelta::Min();
static_assert(kMin.is_min(), "");
static_assert(kMin == TimeDelta::Min(), "");
static_assert(kMin < TimeDelta::FromDays(-100 * 365), "");
static_assert(kMin < kZero, "");
} }
bool IsMin(TimeDelta delta) { constexpr bool IsMin(TimeDelta delta) {
return delta.is_min(); return delta.is_min();
} }
TEST(TimeDelta, MaxConversions) { TEST(TimeDelta, MaxConversions) {
TimeDelta t = TimeDelta::Max(); // static_assert also confirms constexpr works as intended.
EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.ToInternalValue()); constexpr TimeDelta kMax = TimeDelta::Max();
static_assert(kMax.ToInternalValue() == std::numeric_limits<int64_t>::max(),
EXPECT_EQ(std::numeric_limits<int>::max(), t.InDays()); "");
EXPECT_EQ(std::numeric_limits<int>::max(), t.InHours()); EXPECT_EQ(kMax.InDays(), std::numeric_limits<int>::max());
EXPECT_EQ(std::numeric_limits<int>::max(), t.InMinutes()); EXPECT_EQ(kMax.InHours(), std::numeric_limits<int>::max());
EXPECT_EQ(std::numeric_limits<double>::infinity(), t.InSecondsF()); EXPECT_EQ(kMax.InMinutes(), std::numeric_limits<int>::max());
EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.InSeconds()); EXPECT_EQ(kMax.InSecondsF(), std::numeric_limits<double>::infinity());
EXPECT_EQ(std::numeric_limits<double>::infinity(), t.InMillisecondsF()); EXPECT_EQ(kMax.InSeconds(), std::numeric_limits<int64_t>::max());
EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.InMilliseconds()); EXPECT_EQ(kMax.InMillisecondsF(), std::numeric_limits<double>::infinity());
EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.InMillisecondsRoundedUp()); EXPECT_EQ(kMax.InMilliseconds(), std::numeric_limits<int64_t>::max());
EXPECT_EQ(kMax.InMillisecondsRoundedUp(), std::numeric_limits<int64_t>::max());
t = TimeDelta::FromDays(std::numeric_limits<int>::max());
EXPECT_TRUE(t.is_max()); static_assert(TimeDelta::FromDays(std::numeric_limits<int>::max()).is_max(),
"");
t = TimeDelta::FromHours(std::numeric_limits<int>::max()); static_assert(TimeDelta::FromHours(std::numeric_limits<int>::max()).is_max(),
EXPECT_TRUE(t.is_max()); "");
t = TimeDelta::FromMinutes(std::numeric_limits<int>::max()); static_assert(
EXPECT_TRUE(t.is_max()); TimeDelta::FromMinutes(std::numeric_limits<int>::max()).is_max(), "");
int64_t max_int = std::numeric_limits<int64_t>::max(); constexpr int64_t max_int = std::numeric_limits<int64_t>::max();
int64_t min_int = std::numeric_limits<int64_t>::min(); constexpr int64_t min_int = std::numeric_limits<int64_t>::min();
t = TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1); static_assert(
EXPECT_TRUE(t.is_max()); TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1)
.is_max(),
"");
t = TimeDelta::FromMilliseconds(max_int / Time::kMillisecondsPerSecond + 1); static_assert(
EXPECT_TRUE(t.is_max()); TimeDelta::FromMilliseconds(max_int / Time::kMillisecondsPerSecond + 1)
.is_max(),
"");
t = TimeDelta::FromMicroseconds(max_int); static_assert(TimeDelta::FromMicroseconds(max_int).is_max(), "");
EXPECT_TRUE(t.is_max());
t = TimeDelta::FromSeconds(min_int / Time::kMicrosecondsPerSecond - 1); static_assert(
EXPECT_TRUE(IsMin(t)); IsMin(TimeDelta::FromSeconds(min_int / Time::kMicrosecondsPerSecond - 1)),
"");
t = TimeDelta::FromMilliseconds(min_int / Time::kMillisecondsPerSecond - 1); static_assert(IsMin(TimeDelta::FromMilliseconds(
EXPECT_TRUE(IsMin(t)); min_int / Time::kMillisecondsPerSecond - 1)),
"");
t = TimeDelta::FromMicroseconds(min_int); static_assert(IsMin(TimeDelta::FromMicroseconds(min_int)), "");
EXPECT_TRUE(IsMin(t));
t = TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min()); static_assert(
EXPECT_TRUE(IsMin(t)); IsMin(TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min())),
"");
t = TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity()); // Floating point arithmetic resulting in infinity isn't constexpr in C++14.
EXPECT_TRUE(t.is_max()); EXPECT_TRUE(TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity())
.is_max());
double max_d = max_int; constexpr double max_d = max_int;
double min_d = min_int; constexpr double min_d = min_int;
t = TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond + 1); static_assert(
EXPECT_TRUE(t.is_max()); TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond + 1)
.is_max(),
"");
t = TimeDelta::FromMillisecondsD(std::numeric_limits<double>::infinity()); // Floating point arithmetic resulting in infinity isn't constexpr in C++14.
EXPECT_TRUE(t.is_max()); EXPECT_TRUE(
TimeDelta::FromMillisecondsD(std::numeric_limits<double>::infinity())
.is_max());
t = TimeDelta::FromMillisecondsD(max_d / Time::kMillisecondsPerSecond * 2); static_assert(
EXPECT_TRUE(t.is_max()); TimeDelta::FromMillisecondsD(max_d / Time::kMillisecondsPerSecond * 2)
.is_max(),
"");
t = TimeDelta::FromSecondsD(min_d / Time::kMicrosecondsPerSecond - 1); static_assert(
EXPECT_TRUE(IsMin(t)); IsMin(TimeDelta::FromSecondsD(min_d / Time::kMicrosecondsPerSecond - 1)),
"");
t = TimeDelta::FromMillisecondsD(min_d / Time::kMillisecondsPerSecond * 2); static_assert(IsMin(TimeDelta::FromMillisecondsD(
EXPECT_TRUE(IsMin(t)); min_d / Time::kMillisecondsPerSecond * 2)),
"");
} }
TEST(TimeDelta, NumericOperators) { TEST(TimeDelta, NumericOperators) {
double d = 0.5; constexpr double d = 0.5;
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) * d); (TimeDelta::FromMilliseconds(1000) * d));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) / d); (TimeDelta::FromMilliseconds(1000) / d));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) *= d); (TimeDelta::FromMilliseconds(1000) *= d));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) /= d); (TimeDelta::FromMilliseconds(1000) /= d));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
d * TimeDelta::FromMilliseconds(1000)); (d * TimeDelta::FromMilliseconds(1000)));
float f = 0.5; constexpr float f = 0.5;
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) * f); (TimeDelta::FromMilliseconds(1000) * f));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) / f); (TimeDelta::FromMilliseconds(1000) / f));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) *= f); (TimeDelta::FromMilliseconds(1000) *= f));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) /= f); (TimeDelta::FromMilliseconds(1000) /= f));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
f * TimeDelta::FromMilliseconds(1000)); (f * TimeDelta::FromMilliseconds(1000)));
int i = 2; constexpr int i = 2;
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) * i); (TimeDelta::FromMilliseconds(1000) * i));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) / i); (TimeDelta::FromMilliseconds(1000) / i));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) *= i); (TimeDelta::FromMilliseconds(1000) *= i));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) /= i); (TimeDelta::FromMilliseconds(1000) /= i));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
i * TimeDelta::FromMilliseconds(1000)); (i * TimeDelta::FromMilliseconds(1000)));
int64_t i64 = 2; constexpr int64_t i64 = 2;
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) * i64); (TimeDelta::FromMilliseconds(1000) * i64));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) / i64); (TimeDelta::FromMilliseconds(1000) / i64));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) *= i64); (TimeDelta::FromMilliseconds(1000) *= i64));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) /= i64); (TimeDelta::FromMilliseconds(1000) /= i64));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
i64 * TimeDelta::FromMilliseconds(1000)); (i64 * TimeDelta::FromMilliseconds(1000)));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) * 0.5); (TimeDelta::FromMilliseconds(1000) * 0.5));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) / 0.5); (TimeDelta::FromMilliseconds(1000) / 0.5));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) *= 0.5); (TimeDelta::FromMilliseconds(1000) *= 0.5));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) /= 0.5); (TimeDelta::FromMilliseconds(1000) /= 0.5));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
0.5 * TimeDelta::FromMilliseconds(1000)); (0.5 * TimeDelta::FromMilliseconds(1000)));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) * 2); (TimeDelta::FromMilliseconds(1000) * 2));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) / 2); (TimeDelta::FromMilliseconds(1000) / 2));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
TimeDelta::FromMilliseconds(1000) *= 2); (TimeDelta::FromMilliseconds(1000) *= 2));
EXPECT_EQ(TimeDelta::FromMilliseconds(500), EXPECT_EQ(TimeDelta::FromMilliseconds(500),
TimeDelta::FromMilliseconds(1000) /= 2); (TimeDelta::FromMilliseconds(1000) /= 2));
EXPECT_EQ(TimeDelta::FromMilliseconds(2000), EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
2 * TimeDelta::FromMilliseconds(1000)); (2 * TimeDelta::FromMilliseconds(1000)));
}
// Basic test of operators between TimeDeltas (without overflow -- next test
// handles overflow).
TEST(TimeDelta, TimeDeltaOperators) {
constexpr TimeDelta kElevenSeconds = TimeDelta::FromSeconds(11);
constexpr TimeDelta kThreeSeconds = TimeDelta::FromSeconds(3);
EXPECT_EQ(TimeDelta::FromSeconds(14), kElevenSeconds + kThreeSeconds);
EXPECT_EQ(TimeDelta::FromSeconds(14), kThreeSeconds + kElevenSeconds);
EXPECT_EQ(TimeDelta::FromSeconds(8), kElevenSeconds - kThreeSeconds);
EXPECT_EQ(TimeDelta::FromSeconds(-8), kThreeSeconds - kElevenSeconds);
static_assert(3 == kElevenSeconds / kThreeSeconds, "");
static_assert(0 == kThreeSeconds / kElevenSeconds, "");
static_assert(TimeDelta::FromSeconds(2) == kElevenSeconds % kThreeSeconds,
"");
} }
TEST(TimeDelta, Overflows) { TEST(TimeDelta, Overflows) {
// Some sanity checks. // Some sanity checks. static_assert's used were possible to verify constexpr
EXPECT_TRUE(TimeDelta::Max().is_max()); // evaluation at the same time.
EXPECT_LT(-TimeDelta::Max(), TimeDelta()); static_assert(TimeDelta::Max().is_max(), "");
EXPECT_GT(-TimeDelta::Max(), TimeDelta::Min()); static_assert(-TimeDelta::Max() < TimeDelta(), "");
EXPECT_GT(TimeDelta(), -TimeDelta::Max()); static_assert(-TimeDelta::Max() > TimeDelta::Min(), "");
static_assert(TimeDelta() > -TimeDelta::Max(), "");
TimeDelta large_delta = TimeDelta::Max() - TimeDelta::FromMilliseconds(1); TimeDelta large_delta = TimeDelta::Max() - TimeDelta::FromMilliseconds(1);
TimeDelta large_negative = -large_delta; TimeDelta large_negative = -large_delta;
EXPECT_GT(TimeDelta(), large_negative); EXPECT_GT(TimeDelta(), large_negative);
EXPECT_FALSE(large_delta.is_max()); EXPECT_FALSE(large_delta.is_max());
EXPECT_FALSE(IsMin(-large_negative)); EXPECT_FALSE(IsMin(-large_negative));
TimeDelta one_second = TimeDelta::FromSeconds(1); constexpr TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
// Test +, -, * and / operators. // Test +, -, * and / operators.
EXPECT_TRUE((large_delta + one_second).is_max()); EXPECT_TRUE((large_delta + kOneSecond).is_max());
EXPECT_TRUE(IsMin(large_negative + (-one_second))); EXPECT_TRUE(IsMin(large_negative + (-kOneSecond)));
EXPECT_TRUE(IsMin(large_negative - one_second)); EXPECT_TRUE(IsMin(large_negative - kOneSecond));
EXPECT_TRUE((large_delta - (-one_second)).is_max()); EXPECT_TRUE((large_delta - (-kOneSecond)).is_max());
EXPECT_TRUE((large_delta * 2).is_max()); EXPECT_TRUE((large_delta * 2).is_max());
EXPECT_TRUE(IsMin(large_delta * -2)); EXPECT_TRUE(IsMin(large_delta * -2));
EXPECT_TRUE((large_delta / 0.5).is_max()); EXPECT_TRUE((large_delta / 0.5).is_max());
...@@ -1384,17 +1433,17 @@ TEST(TimeDelta, Overflows) { ...@@ -1384,17 +1433,17 @@ TEST(TimeDelta, Overflows) {
// Test +=, -=, *= and /= operators. // Test +=, -=, *= and /= operators.
TimeDelta delta = large_delta; TimeDelta delta = large_delta;
delta += one_second; delta += kOneSecond;
EXPECT_TRUE(delta.is_max()); EXPECT_TRUE(delta.is_max());
delta = large_negative; delta = large_negative;
delta += -one_second; delta += -kOneSecond;
EXPECT_TRUE(IsMin(delta)); EXPECT_TRUE(IsMin(delta));
delta = large_negative; delta = large_negative;
delta -= one_second; delta -= kOneSecond;
EXPECT_TRUE(IsMin(delta)); EXPECT_TRUE(IsMin(delta));
delta = large_delta; delta = large_delta;
delta -= -one_second; delta -= -kOneSecond;
EXPECT_TRUE(delta.is_max()); EXPECT_TRUE(delta.is_max());
delta = large_delta; delta = large_delta;
...@@ -1418,12 +1467,12 @@ TEST(TimeDelta, Overflows) { ...@@ -1418,12 +1467,12 @@ TEST(TimeDelta, Overflows) {
EXPECT_TRUE((TimeTicks::Now() + large_delta).is_max()); EXPECT_TRUE((TimeTicks::Now() + large_delta).is_max());
Time time_now = Time::Now(); Time time_now = Time::Now();
EXPECT_EQ(one_second, (time_now + one_second) - time_now); EXPECT_EQ(kOneSecond, (time_now + kOneSecond) - time_now);
EXPECT_EQ(-one_second, (time_now - one_second) - time_now); EXPECT_EQ(-kOneSecond, (time_now - kOneSecond) - time_now);
TimeTicks ticks_now = TimeTicks::Now(); TimeTicks ticks_now = TimeTicks::Now();
EXPECT_EQ(-one_second, (ticks_now - one_second) - ticks_now); EXPECT_EQ(-kOneSecond, (ticks_now - kOneSecond) - ticks_now);
EXPECT_EQ(one_second, (ticks_now + one_second) - ticks_now); EXPECT_EQ(kOneSecond, (ticks_now + kOneSecond) - ticks_now);
} }
TEST(TimeDeltaLogging, DCheckEqCompiles) { TEST(TimeDeltaLogging, DCheckEqCompiles) {
...@@ -1431,18 +1480,18 @@ TEST(TimeDeltaLogging, DCheckEqCompiles) { ...@@ -1431,18 +1480,18 @@ TEST(TimeDeltaLogging, DCheckEqCompiles) {
} }
TEST(TimeDeltaLogging, EmptyIsZero) { TEST(TimeDeltaLogging, EmptyIsZero) {
TimeDelta zero; constexpr TimeDelta kZero;
EXPECT_EQ("0 s", AnyToString(zero)); EXPECT_EQ("0 s", AnyToString(kZero));
} }
TEST(TimeDeltaLogging, FiveHundredMs) { TEST(TimeDeltaLogging, FiveHundredMs) {
TimeDelta five_hundred_ms = TimeDelta::FromMilliseconds(500); constexpr TimeDelta kFiveHundredMs = TimeDelta::FromMilliseconds(500);
EXPECT_EQ("0.5 s", AnyToString(five_hundred_ms)); EXPECT_EQ("0.5 s", AnyToString(kFiveHundredMs));
} }
TEST(TimeDeltaLogging, MinusTenSeconds) { TEST(TimeDeltaLogging, MinusTenSeconds) {
TimeDelta minus_ten_seconds = TimeDelta::FromSeconds(-10); constexpr TimeDelta kMinusTenSeconds = TimeDelta::FromSeconds(-10);
EXPECT_EQ("-10 s", AnyToString(minus_ten_seconds)); EXPECT_EQ("-10 s", AnyToString(kMinusTenSeconds));
} }
TEST(TimeDeltaLogging, DoesNotMessUpFormattingFlags) { TEST(TimeDeltaLogging, DoesNotMessUpFormattingFlags) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment