admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add TimeDelta and Timestamp factories

Browse Source 
These factories suppose to replace set of old constexpr factories that
takes parameter as template rather than function parameter,
as well as fix function naming to follow style guide of the second set
of factory functions.

Bug: None
Change-Id: Icd76302b821b2a4027f9d6765cf91bc9190f551c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/167521
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30482}
This commit is contained in:
Danil Chapovalov 2020-01-28 17:54:47 +01:00 committed by Commit Bot
parent 3663f94143
commit 8d94dc23a6
4 changed files with 153 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
api/units/time_delta.h
View File

@ -32,7 +32,26 @@ namespace webrtc {
// microseconds (us). // microseconds (us).
class TimeDelta final : public rtc_units_impl::RelativeUnit<TimeDelta> { class TimeDelta final : public rtc_units_impl::RelativeUnit<TimeDelta> {
public: public:
template <typename T>
static constexpr TimeDelta Seconds(T value) {
static_assert(std::is_arithmetic<T>::value, "");
return FromFraction(1'000'000, value);
}
template <typename T>
static constexpr TimeDelta Millis(T value) {
static_assert(std::is_arithmetic<T>::value, "");
return FromFraction(1'000, value);
}
template <typename T>
static constexpr TimeDelta Micros(T value) {
static_assert(std::is_arithmetic<T>::value, "");
return FromValue(value);
}
TimeDelta() = delete; TimeDelta() = delete;
// TODO(danilchap): Migrate all code to the 3 factories above and delete the
// 6 factories below.
template <int64_t seconds> template <int64_t seconds>
static constexpr TimeDelta Seconds() { static constexpr TimeDelta Seconds() {
return FromFraction(1'000'000, seconds); return FromFraction(1'000'000, seconds);

131
api/units/time_delta_unittest.cc
View File

@ -28,9 +28,9 @@ TEST(TimeDeltaTest, ConstExpr) {
static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, ""); static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, "");
constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds<kValue>(); constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds(kValue);
constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis<kValue>(); constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis(kValue);
constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros<kValue>(); constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros(kValue);
static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, ""); static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, "");
static_assert(kTimeDeltaMs.ms_or(0) == kValue, ""); static_assert(kTimeDeltaMs.ms_or(0) == kValue, "");
@ -41,40 +41,40 @@ TEST(TimeDeltaTest, GetBackSameValues) {
const int64_t kValue = 499; const int64_t kValue = 499;
for (int sign = -1; sign <= 1; ++sign) { for (int sign = -1; sign <= 1; ++sign) {
int64_t value = kValue * sign; int64_t value = kValue * sign;
EXPECT_EQ(TimeDelta::ms(value).ms(), value); EXPECT_EQ(TimeDelta::Millis(value).ms(), value);
EXPECT_EQ(TimeDelta::us(value).us(), value); EXPECT_EQ(TimeDelta::Micros(value).us(), value);
EXPECT_EQ(TimeDelta::seconds(value).seconds(), value); EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value);
EXPECT_EQ(TimeDelta::seconds(value).seconds(), value); EXPECT_EQ(TimeDelta::Seconds(value).seconds(), value);
} }
EXPECT_EQ(TimeDelta::Zero().us(), 0); EXPECT_EQ(TimeDelta::Zero().us(), 0);
} }
TEST(TimeDeltaTest, GetDifferentPrefix) { TEST(TimeDeltaTest, GetDifferentPrefix) {
const int64_t kValue = 3000000; const int64_t kValue = 3000000;
EXPECT_EQ(TimeDelta::us(kValue).seconds(), kValue / 1000000); EXPECT_EQ(TimeDelta::Micros(kValue).seconds(), kValue / 1000000);
EXPECT_EQ(TimeDelta::ms(kValue).seconds(), kValue / 1000); EXPECT_EQ(TimeDelta::Millis(kValue).seconds(), kValue / 1000);
EXPECT_EQ(TimeDelta::us(kValue).ms(), kValue / 1000); EXPECT_EQ(TimeDelta::Micros(kValue).ms(), kValue / 1000);
EXPECT_EQ(TimeDelta::ms(kValue).us(), kValue * 1000); EXPECT_EQ(TimeDelta::Millis(kValue).us(), kValue * 1000);
EXPECT_EQ(TimeDelta::seconds(kValue).ms(), kValue * 1000); EXPECT_EQ(TimeDelta::Seconds(kValue).ms(), kValue * 1000);
EXPECT_EQ(TimeDelta::seconds(kValue).us(), kValue * 1000000); EXPECT_EQ(TimeDelta::Seconds(kValue).us(), kValue * 1000000);
} }
TEST(TimeDeltaTest, IdentityChecks) { TEST(TimeDeltaTest, IdentityChecks) {
const int64_t kValue = 3000; const int64_t kValue = 3000;
EXPECT_TRUE(TimeDelta::Zero().IsZero()); EXPECT_TRUE(TimeDelta::Zero().IsZero());
EXPECT_FALSE(TimeDelta::ms(kValue).IsZero()); EXPECT_FALSE(TimeDelta::Millis(kValue).IsZero());
EXPECT_TRUE(TimeDelta::PlusInfinity().IsInfinite()); EXPECT_TRUE(TimeDelta::PlusInfinity().IsInfinite());
EXPECT_TRUE(TimeDelta::MinusInfinity().IsInfinite()); EXPECT_TRUE(TimeDelta::MinusInfinity().IsInfinite());
EXPECT_FALSE(TimeDelta::Zero().IsInfinite()); EXPECT_FALSE(TimeDelta::Zero().IsInfinite());
EXPECT_FALSE(TimeDelta::ms(-kValue).IsInfinite()); EXPECT_FALSE(TimeDelta::Millis(-kValue).IsInfinite());
EXPECT_FALSE(TimeDelta::ms(kValue).IsInfinite()); EXPECT_FALSE(TimeDelta::Millis(kValue).IsInfinite());
EXPECT_FALSE(TimeDelta::PlusInfinity().IsFinite()); EXPECT_FALSE(TimeDelta::PlusInfinity().IsFinite());
EXPECT_FALSE(TimeDelta::MinusInfinity().IsFinite()); EXPECT_FALSE(TimeDelta::MinusInfinity().IsFinite());
EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite()); EXPECT_TRUE(TimeDelta::Millis(-kValue).IsFinite());
EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite()); EXPECT_TRUE(TimeDelta::Millis(kValue).IsFinite());
EXPECT_TRUE(TimeDelta::Zero().IsFinite()); EXPECT_TRUE(TimeDelta::Zero().IsFinite());
EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity()); EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
@ -87,33 +87,33 @@ TEST(TimeDeltaTest, IdentityChecks) {
TEST(TimeDeltaTest, ComparisonOperators) { TEST(TimeDeltaTest, ComparisonOperators) {
const int64_t kSmall = 450; const int64_t kSmall = 450;
const int64_t kLarge = 451; const int64_t kLarge = 451;
const TimeDelta small = TimeDelta::ms(kSmall); const TimeDelta small = TimeDelta::Millis(kSmall);
const TimeDelta large = TimeDelta::ms(kLarge); const TimeDelta large = TimeDelta::Millis(kLarge);
EXPECT_EQ(TimeDelta::Zero(), TimeDelta::ms(0)); EXPECT_EQ(TimeDelta::Zero(), TimeDelta::Millis(0));
EXPECT_EQ(TimeDelta::PlusInfinity(), TimeDelta::PlusInfinity()); EXPECT_EQ(TimeDelta::PlusInfinity(), TimeDelta::PlusInfinity());
EXPECT_EQ(small, TimeDelta::ms(kSmall)); EXPECT_EQ(small, TimeDelta::Millis(kSmall));
EXPECT_LE(small, TimeDelta::ms(kSmall)); EXPECT_LE(small, TimeDelta::Millis(kSmall));
EXPECT_GE(small, TimeDelta::ms(kSmall)); EXPECT_GE(small, TimeDelta::Millis(kSmall));
EXPECT_NE(small, TimeDelta::ms(kLarge)); EXPECT_NE(small, TimeDelta::Millis(kLarge));
EXPECT_LE(small, TimeDelta::ms(kLarge)); EXPECT_LE(small, TimeDelta::Millis(kLarge));
EXPECT_LT(small, TimeDelta::ms(kLarge)); EXPECT_LT(small, TimeDelta::Millis(kLarge));
EXPECT_GE(large, TimeDelta::ms(kSmall)); EXPECT_GE(large, TimeDelta::Millis(kSmall));
EXPECT_GT(large, TimeDelta::ms(kSmall)); EXPECT_GT(large, TimeDelta::Millis(kSmall));
EXPECT_LT(TimeDelta::Zero(), small); EXPECT_LT(TimeDelta::Zero(), small);
EXPECT_GT(TimeDelta::Zero(), TimeDelta::ms(-kSmall)); EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
EXPECT_GT(TimeDelta::Zero(), TimeDelta::ms(-kSmall)); EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
EXPECT_GT(TimeDelta::PlusInfinity(), large); EXPECT_GT(TimeDelta::PlusInfinity(), large);
EXPECT_LT(TimeDelta::MinusInfinity(), TimeDelta::Zero()); EXPECT_LT(TimeDelta::MinusInfinity(), TimeDelta::Zero());
} }
TEST(TimeDeltaTest, Clamping) { TEST(TimeDeltaTest, Clamping) {
const TimeDelta upper = TimeDelta::ms(800); const TimeDelta upper = TimeDelta::Millis(800);
const TimeDelta lower = TimeDelta::ms(100); const TimeDelta lower = TimeDelta::Millis(100);
const TimeDelta under = TimeDelta::ms(100); const TimeDelta under = TimeDelta::Millis(100);
const TimeDelta inside = TimeDelta::ms(500); const TimeDelta inside = TimeDelta::Millis(500);
const TimeDelta over = TimeDelta::ms(1000); const TimeDelta over = TimeDelta::Millis(1000);
EXPECT_EQ(under.Clamped(lower, upper), lower); EXPECT_EQ(under.Clamped(lower, upper), lower);
EXPECT_EQ(inside.Clamped(lower, upper), inside); EXPECT_EQ(inside.Clamped(lower, upper), inside);
EXPECT_EQ(over.Clamped(lower, upper), upper); EXPECT_EQ(over.Clamped(lower, upper), upper);
@ -131,9 +131,10 @@ TEST(TimeDeltaTest, Clamping) {
TEST(TimeDeltaTest, CanBeInititializedFromLargeInt) { TEST(TimeDeltaTest, CanBeInititializedFromLargeInt) {
const int kMaxInt = std::numeric_limits<int>::max(); const int kMaxInt = std::numeric_limits<int>::max();
EXPECT_EQ(TimeDelta::seconds(kMaxInt).us(), EXPECT_EQ(TimeDelta::Seconds(kMaxInt).us(),
static_cast<int64_t>(kMaxInt) * 1000000); static_cast<int64_t>(kMaxInt) * 1000000);
EXPECT_EQ(TimeDelta::ms(kMaxInt).us(), static_cast<int64_t>(kMaxInt) * 1000); EXPECT_EQ(TimeDelta::Millis(kMaxInt).us(),
static_cast<int64_t>(kMaxInt) * 1000);
} }
TEST(TimeDeltaTest, ConvertsToAndFromDouble) { TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
@ -143,16 +144,16 @@ TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
const double kMillisDouble = kMicros * 1e-3; const double kMillisDouble = kMicros * 1e-3;
const double kSecondsDouble = kMillisDouble * 1e-3; const double kSecondsDouble = kMillisDouble * 1e-3;
EXPECT_EQ(TimeDelta::us(kMicros).seconds<double>(), kSecondsDouble); EXPECT_EQ(TimeDelta::Micros(kMicros).seconds<double>(), kSecondsDouble);
EXPECT_EQ(TimeDelta::seconds(kSecondsDouble).us(), kMicros); EXPECT_EQ(TimeDelta::Seconds(kSecondsDouble).us(), kMicros);
EXPECT_EQ(TimeDelta::us(kMicros).ms<double>(), kMillisDouble); EXPECT_EQ(TimeDelta::Micros(kMicros).ms<double>(), kMillisDouble);
EXPECT_EQ(TimeDelta::ms(kMillisDouble).us(), kMicros); EXPECT_EQ(TimeDelta::Millis(kMillisDouble).us(), kMicros);
EXPECT_EQ(TimeDelta::us(kMicros).us<double>(), kMicrosDouble); EXPECT_EQ(TimeDelta::Micros(kMicros).us<double>(), kMicrosDouble);
EXPECT_EQ(TimeDelta::us(kMicrosDouble).us(), kMicros); EXPECT_EQ(TimeDelta::Micros(kMicrosDouble).us(), kMicros);
EXPECT_NEAR(TimeDelta::us(kMicros).ns<double>(), kNanosDouble, 1); EXPECT_NEAR(TimeDelta::Micros(kMicros).ns<double>(), kNanosDouble, 1);
const double kPlusInfinity = std::numeric_limits<double>::infinity(); const double kPlusInfinity = std::numeric_limits<double>::infinity();
const double kMinusInfinity = -kPlusInfinity; const double kMinusInfinity = -kPlusInfinity;
@ -166,44 +167,46 @@ TEST(TimeDeltaTest, ConvertsToAndFromDouble) {
EXPECT_EQ(TimeDelta::PlusInfinity().ns<double>(), kPlusInfinity); EXPECT_EQ(TimeDelta::PlusInfinity().ns<double>(), kPlusInfinity);
EXPECT_EQ(TimeDelta::MinusInfinity().ns<double>(), kMinusInfinity); EXPECT_EQ(TimeDelta::MinusInfinity().ns<double>(), kMinusInfinity);
EXPECT_TRUE(TimeDelta::seconds(kPlusInfinity).IsPlusInfinity()); EXPECT_TRUE(TimeDelta::Seconds(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(TimeDelta::seconds(kMinusInfinity).IsMinusInfinity()); EXPECT_TRUE(TimeDelta::Seconds(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(TimeDelta::ms(kPlusInfinity).IsPlusInfinity()); EXPECT_TRUE(TimeDelta::Millis(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(TimeDelta::ms(kMinusInfinity).IsMinusInfinity()); EXPECT_TRUE(TimeDelta::Millis(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(TimeDelta::us(kPlusInfinity).IsPlusInfinity()); EXPECT_TRUE(TimeDelta::Micros(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(TimeDelta::us(kMinusInfinity).IsMinusInfinity()); EXPECT_TRUE(TimeDelta::Micros(kMinusInfinity).IsMinusInfinity());
} }
TEST(TimeDeltaTest, MathOperations) { TEST(TimeDeltaTest, MathOperations) {
const int64_t kValueA = 267; const int64_t kValueA = 267;
const int64_t kValueB = 450; const int64_t kValueB = 450;
const TimeDelta delta_a = TimeDelta::ms(kValueA); const TimeDelta delta_a = TimeDelta::Millis(kValueA);
const TimeDelta delta_b = TimeDelta::ms(kValueB); const TimeDelta delta_b = TimeDelta::Millis(kValueB);
EXPECT_EQ((delta_a + delta_b).ms(), kValueA + kValueB); EXPECT_EQ((delta_a + delta_b).ms(), kValueA + kValueB);
EXPECT_EQ((delta_a - delta_b).ms(), kValueA - kValueB); EXPECT_EQ((delta_a - delta_b).ms(), kValueA - kValueB);
const int32_t kInt32Value = 123; const int32_t kInt32Value = 123;
const double kFloatValue = 123.0; const double kFloatValue = 123.0;
EXPECT_EQ((TimeDelta::us(kValueA) * kValueB).us(), kValueA * kValueB); EXPECT_EQ((TimeDelta::Micros(kValueA) * kValueB).us(), kValueA * kValueB);
EXPECT_EQ((TimeDelta::us(kValueA) * kInt32Value).us(), kValueA * kInt32Value); EXPECT_EQ((TimeDelta::Micros(kValueA) * kInt32Value).us(),
EXPECT_EQ((TimeDelta::us(kValueA) * kFloatValue).us(), kValueA * kFloatValue); kValueA * kInt32Value);
EXPECT_EQ((TimeDelta::Micros(kValueA) * kFloatValue).us(),
kValueA * kFloatValue);
EXPECT_EQ((delta_b / 10).ms(), kValueB / 10); EXPECT_EQ((delta_b / 10).ms(), kValueB / 10);
EXPECT_EQ(delta_b / delta_a, static_cast<double>(kValueB) / kValueA); EXPECT_EQ(delta_b / delta_a, static_cast<double>(kValueB) / kValueA);
EXPECT_EQ(TimeDelta::us(-kValueA).Abs().us(), kValueA); EXPECT_EQ(TimeDelta::Micros(-kValueA).Abs().us(), kValueA);
EXPECT_EQ(TimeDelta::us(kValueA).Abs().us(), kValueA); EXPECT_EQ(TimeDelta::Micros(kValueA).Abs().us(), kValueA);
TimeDelta mutable_delta = TimeDelta::ms(kValueA); TimeDelta mutable_delta = TimeDelta::Millis(kValueA);
mutable_delta += TimeDelta::ms(kValueB); mutable_delta += TimeDelta::Millis(kValueB);
EXPECT_EQ(mutable_delta, TimeDelta::ms(kValueA + kValueB)); EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA + kValueB));
mutable_delta -= TimeDelta::ms(kValueB); mutable_delta -= TimeDelta::Millis(kValueB);
EXPECT_EQ(mutable_delta, TimeDelta::ms(kValueA)); EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA));
} }
TEST(TimeDeltaTest, InfinityOperations) { TEST(TimeDeltaTest, InfinityOperations) {
const int64_t kValue = 267; const int64_t kValue = 267;
const TimeDelta finite = TimeDelta::ms(kValue); const TimeDelta finite = TimeDelta::Millis(kValue);
EXPECT_TRUE((TimeDelta::PlusInfinity() + finite).IsPlusInfinity()); EXPECT_TRUE((TimeDelta::PlusInfinity() + finite).IsPlusInfinity());
EXPECT_TRUE((TimeDelta::PlusInfinity() - finite).IsPlusInfinity()); EXPECT_TRUE((TimeDelta::PlusInfinity() - finite).IsPlusInfinity());
EXPECT_TRUE((finite + TimeDelta::PlusInfinity()).IsPlusInfinity()); EXPECT_TRUE((finite + TimeDelta::PlusInfinity()).IsPlusInfinity());

18
api/units/timestamp.h
View File

@ -28,8 +28,26 @@ namespace webrtc {
// difference of two Timestamps results in a TimeDelta. // difference of two Timestamps results in a TimeDelta.
class Timestamp final : public rtc_units_impl::UnitBase<Timestamp> { class Timestamp final : public rtc_units_impl::UnitBase<Timestamp> {
public: public:
template <typename T>
static constexpr Timestamp Seconds(T value) {
static_assert(std::is_arithmetic<T>::value, "");
return FromFraction(1'000'000, value);
}
template <typename T>
static constexpr Timestamp Millis(T value) {
static_assert(std::is_arithmetic<T>::value, "");
return FromFraction(1'000, value);
}
template <typename T>
static constexpr Timestamp Micros(T value) {
static_assert(std::is_arithmetic<T>::value, "");
return FromValue(value);
}
Timestamp() = delete; Timestamp() = delete;
// TODO(danilchap): Migrate all code to the 3 factories above and delete the
// 6 factories below.
template <int64_t seconds> template <int64_t seconds>
static constexpr Timestamp Seconds() { static constexpr Timestamp Seconds() {
return FromFraction(1'000'000, seconds); return FromFraction(1'000'000, seconds);

95
api/units/timestamp_unittest.cc
View File

@ -8,6 +8,8 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <limits>
#include "api/units/timestamp.h" #include "api/units/timestamp.h"
#include "test/gtest.h" #include "test/gtest.h"
@ -19,9 +21,9 @@ TEST(TimestampTest, ConstExpr) {
static_assert(kTimestampInf.IsInfinite(), ""); static_assert(kTimestampInf.IsInfinite(), "");
static_assert(kTimestampInf.ms_or(-1) == -1, ""); static_assert(kTimestampInf.ms_or(-1) == -1, "");
constexpr Timestamp kTimestampSeconds = Timestamp::Seconds<kValue>(); constexpr Timestamp kTimestampSeconds = Timestamp::Seconds(kValue);
constexpr Timestamp kTimestampMs = Timestamp::Millis<kValue>(); constexpr Timestamp kTimestampMs = Timestamp::Millis(kValue);
constexpr Timestamp kTimestampUs = Timestamp::Micros<kValue>(); constexpr Timestamp kTimestampUs = Timestamp::Micros(kValue);
static_assert(kTimestampSeconds.seconds_or(0) == kValue, ""); static_assert(kTimestampSeconds.seconds_or(0) == kValue, "");
static_assert(kTimestampMs.ms_or(0) == kValue, ""); static_assert(kTimestampMs.ms_or(0) == kValue, "");
@ -36,20 +38,20 @@ TEST(TimestampTest, ConstExpr) {
TEST(TimestampTest, GetBackSameValues) { TEST(TimestampTest, GetBackSameValues) {
const int64_t kValue = 499; const int64_t kValue = 499;
EXPECT_EQ(Timestamp::ms(kValue).ms(), kValue); EXPECT_EQ(Timestamp::Millis(kValue).ms(), kValue);
EXPECT_EQ(Timestamp::us(kValue).us(), kValue); EXPECT_EQ(Timestamp::Micros(kValue).us(), kValue);
EXPECT_EQ(Timestamp::seconds(kValue).seconds(), kValue); EXPECT_EQ(Timestamp::Seconds(kValue).seconds(), kValue);
} }
TEST(TimestampTest, GetDifferentPrefix) { TEST(TimestampTest, GetDifferentPrefix) {
const int64_t kValue = 3000000; const int64_t kValue = 3000000;
EXPECT_EQ(Timestamp::us(kValue).seconds(), kValue / 1000000); EXPECT_EQ(Timestamp::Micros(kValue).seconds(), kValue / 1000000);
EXPECT_EQ(Timestamp::ms(kValue).seconds(), kValue / 1000); EXPECT_EQ(Timestamp::Millis(kValue).seconds(), kValue / 1000);
EXPECT_EQ(Timestamp::us(kValue).ms(), kValue / 1000); EXPECT_EQ(Timestamp::Micros(kValue).ms(), kValue / 1000);
EXPECT_EQ(Timestamp::ms(kValue).us(), kValue * 1000); EXPECT_EQ(Timestamp::Millis(kValue).us(), kValue * 1000);
EXPECT_EQ(Timestamp::seconds(kValue).ms(), kValue * 1000); EXPECT_EQ(Timestamp::Seconds(kValue).ms(), kValue * 1000);
EXPECT_EQ(Timestamp::seconds(kValue).us(), kValue * 1000000); EXPECT_EQ(Timestamp::Seconds(kValue).us(), kValue * 1000000);
} }
TEST(TimestampTest, IdentityChecks) { TEST(TimestampTest, IdentityChecks) {
@ -57,11 +59,11 @@ TEST(TimestampTest, IdentityChecks) {
EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite()); EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite());
EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite()); EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite());
EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite()); EXPECT_FALSE(Timestamp::Millis(kValue).IsInfinite());
EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite()); EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite());
EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite()); EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite());
EXPECT_TRUE(Timestamp::ms(kValue).IsFinite()); EXPECT_TRUE(Timestamp::Millis(kValue).IsFinite());
EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity()); EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity()); EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
@ -76,22 +78,23 @@ TEST(TimestampTest, ComparisonOperators) {
EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity()); EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity()); EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge)); EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::Millis(kLarge));
EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); EXPECT_EQ(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); EXPECT_LE(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall)); EXPECT_GE(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
EXPECT_NE(Timestamp::ms(kSmall), Timestamp::ms(kLarge)); EXPECT_NE(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kLarge)); EXPECT_LE(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
EXPECT_LT(Timestamp::ms(kSmall), Timestamp::ms(kLarge)); EXPECT_LT(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
EXPECT_GE(Timestamp::ms(kLarge), Timestamp::ms(kSmall)); EXPECT_GE(Timestamp::Millis(kLarge), Timestamp::Millis(kSmall));
EXPECT_GT(Timestamp::ms(kLarge), Timestamp::ms(kSmall)); EXPECT_GT(Timestamp::Millis(kLarge), Timestamp::Millis(kSmall));
} }
TEST(TimestampTest, CanBeInititializedFromLargeInt) { TEST(TimestampTest, CanBeInititializedFromLargeInt) {
const int kMaxInt = std::numeric_limits<int>::max(); const int kMaxInt = std::numeric_limits<int>::max();
EXPECT_EQ(Timestamp::seconds(kMaxInt).us(), EXPECT_EQ(Timestamp::Seconds(kMaxInt).us(),
static_cast<int64_t>(kMaxInt) * 1000000); static_cast<int64_t>(kMaxInt) * 1000000);
EXPECT_EQ(Timestamp::ms(kMaxInt).us(), static_cast<int64_t>(kMaxInt) * 1000); EXPECT_EQ(Timestamp::Millis(kMaxInt).us(),
static_cast<int64_t>(kMaxInt) * 1000);
} }
TEST(TimestampTest, ConvertsToAndFromDouble) { TEST(TimestampTest, ConvertsToAndFromDouble) {
@ -100,14 +103,14 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
const double kMillisDouble = kMicros * 1e-3; const double kMillisDouble = kMicros * 1e-3;
const double kSecondsDouble = kMillisDouble * 1e-3; const double kSecondsDouble = kMillisDouble * 1e-3;
EXPECT_EQ(Timestamp::us(kMicros).seconds<double>(), kSecondsDouble); EXPECT_EQ(Timestamp::Micros(kMicros).seconds<double>(), kSecondsDouble);
EXPECT_EQ(Timestamp::seconds(kSecondsDouble).us(), kMicros); EXPECT_EQ(Timestamp::Seconds(kSecondsDouble).us(), kMicros);
EXPECT_EQ(Timestamp::us(kMicros).ms<double>(), kMillisDouble); EXPECT_EQ(Timestamp::Micros(kMicros).ms<double>(), kMillisDouble);
EXPECT_EQ(Timestamp::ms(kMillisDouble).us(), kMicros); EXPECT_EQ(Timestamp::Millis(kMillisDouble).us(), kMicros);
EXPECT_EQ(Timestamp::us(kMicros).us<double>(), kMicrosDouble); EXPECT_EQ(Timestamp::Micros(kMicros).us<double>(), kMicrosDouble);
EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros); EXPECT_EQ(Timestamp::Micros(kMicrosDouble).us(), kMicros);
const double kPlusInfinity = std::numeric_limits<double>::infinity(); const double kPlusInfinity = std::numeric_limits<double>::infinity();
const double kMinusInfinity = -kPlusInfinity; const double kMinusInfinity = -kPlusInfinity;
@ -119,25 +122,25 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity); EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity); EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity()); EXPECT_TRUE(Timestamp::Seconds(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity()); EXPECT_TRUE(Timestamp::Seconds(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity()); EXPECT_TRUE(Timestamp::Millis(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity()); EXPECT_TRUE(Timestamp::Millis(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity()); EXPECT_TRUE(Timestamp::Micros(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity()); EXPECT_TRUE(Timestamp::Micros(kMinusInfinity).IsMinusInfinity());
} }
TEST(UnitConversionTest, TimestampAndTimeDeltaMath) { TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
const int64_t kValueA = 267; const int64_t kValueA = 267;
const int64_t kValueB = 450; const int64_t kValueB = 450;
const Timestamp time_a = Timestamp::ms(kValueA); const Timestamp time_a = Timestamp::Millis(kValueA);
const Timestamp time_b = Timestamp::ms(kValueB); const Timestamp time_b = Timestamp::Millis(kValueB);
const TimeDelta delta_a = TimeDelta::ms(kValueA); const TimeDelta delta_a = TimeDelta::Millis(kValueA);
const TimeDelta delta_b = TimeDelta::ms(kValueB); const TimeDelta delta_b = TimeDelta::Millis(kValueB);
EXPECT_EQ((time_a - time_b), TimeDelta::ms(kValueA - kValueB)); EXPECT_EQ((time_a - time_b), TimeDelta::Millis(kValueA - kValueB));
EXPECT_EQ((time_b - delta_a), Timestamp::ms(kValueB - kValueA)); EXPECT_EQ((time_b - delta_a), Timestamp::Millis(kValueB - kValueA));
EXPECT_EQ((time_b + delta_a), Timestamp::ms(kValueB + kValueA)); EXPECT_EQ((time_b + delta_a), Timestamp::Millis(kValueB + kValueA));
Timestamp mutable_time = time_a; Timestamp mutable_time = time_a;
mutable_time += delta_b; mutable_time += delta_b;
@ -148,8 +151,8 @@ TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
TEST(UnitConversionTest, InfinityOperations) { TEST(UnitConversionTest, InfinityOperations) {
const int64_t kValue = 267; const int64_t kValue = 267;
const Timestamp finite_time = Timestamp::ms(kValue); const Timestamp finite_time = Timestamp::Millis(kValue);
const TimeDelta finite_delta = TimeDelta::ms(kValue); const TimeDelta finite_delta = TimeDelta::Millis(kValue);
EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite()); EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite()); EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite()); EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());