Add TimeDelta and Timestamp factories
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}
diff --git a/api/units/time_delta.h b/api/units/time_delta.h
index 030974f..a53ffee 100644
--- a/api/units/time_delta.h
+++ b/api/units/time_delta.h
@@ -32,7 +32,26 @@
// microseconds (us).
class TimeDelta final : public rtc_units_impl::RelativeUnit<TimeDelta> {
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;
+
+ // TODO(danilchap): Migrate all code to the 3 factories above and delete the
+ // 6 factories below.
template <int64_t seconds>
static constexpr TimeDelta Seconds() {
return FromFraction(1'000'000, seconds);
diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index a46ba83..cb43860 100644
--- a/api/units/time_delta_unittest.cc
+++ b/api/units/time_delta_unittest.cc
@@ -28,9 +28,9 @@
static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, "");
- constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds<kValue>();
- constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis<kValue>();
- constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros<kValue>();
+ constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds(kValue);
+ constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis(kValue);
+ constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros(kValue);
static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, "");
static_assert(kTimeDeltaMs.ms_or(0) == kValue, "");
@@ -41,40 +41,40 @@
const int64_t kValue = 499;
for (int sign = -1; sign <= 1; ++sign) {
int64_t value = kValue * sign;
- EXPECT_EQ(TimeDelta::ms(value).ms(), value);
- EXPECT_EQ(TimeDelta::us(value).us(), value);
- EXPECT_EQ(TimeDelta::seconds(value).seconds(), value);
- EXPECT_EQ(TimeDelta::seconds(value).seconds(), value);
+ EXPECT_EQ(TimeDelta::Millis(value).ms(), 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::Zero().us(), 0);
}
TEST(TimeDeltaTest, GetDifferentPrefix) {
const int64_t kValue = 3000000;
- EXPECT_EQ(TimeDelta::us(kValue).seconds(), kValue / 1000000);
- EXPECT_EQ(TimeDelta::ms(kValue).seconds(), kValue / 1000);
- EXPECT_EQ(TimeDelta::us(kValue).ms(), kValue / 1000);
+ EXPECT_EQ(TimeDelta::Micros(kValue).seconds(), kValue / 1000000);
+ EXPECT_EQ(TimeDelta::Millis(kValue).seconds(), kValue / 1000);
+ EXPECT_EQ(TimeDelta::Micros(kValue).ms(), kValue / 1000);
- EXPECT_EQ(TimeDelta::ms(kValue).us(), kValue * 1000);
- EXPECT_EQ(TimeDelta::seconds(kValue).ms(), kValue * 1000);
- EXPECT_EQ(TimeDelta::seconds(kValue).us(), kValue * 1000000);
+ EXPECT_EQ(TimeDelta::Millis(kValue).us(), kValue * 1000);
+ EXPECT_EQ(TimeDelta::Seconds(kValue).ms(), kValue * 1000);
+ EXPECT_EQ(TimeDelta::Seconds(kValue).us(), kValue * 1000000);
}
TEST(TimeDeltaTest, IdentityChecks) {
const int64_t kValue = 3000;
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::MinusInfinity().IsInfinite());
EXPECT_FALSE(TimeDelta::Zero().IsInfinite());
- EXPECT_FALSE(TimeDelta::ms(-kValue).IsInfinite());
- EXPECT_FALSE(TimeDelta::ms(kValue).IsInfinite());
+ EXPECT_FALSE(TimeDelta::Millis(-kValue).IsInfinite());
+ EXPECT_FALSE(TimeDelta::Millis(kValue).IsInfinite());
EXPECT_FALSE(TimeDelta::PlusInfinity().IsFinite());
EXPECT_FALSE(TimeDelta::MinusInfinity().IsFinite());
- EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite());
- EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite());
+ EXPECT_TRUE(TimeDelta::Millis(-kValue).IsFinite());
+ EXPECT_TRUE(TimeDelta::Millis(kValue).IsFinite());
EXPECT_TRUE(TimeDelta::Zero().IsFinite());
EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
@@ -87,33 +87,33 @@
TEST(TimeDeltaTest, ComparisonOperators) {
const int64_t kSmall = 450;
const int64_t kLarge = 451;
- const TimeDelta small = TimeDelta::ms(kSmall);
- const TimeDelta large = TimeDelta::ms(kLarge);
+ const TimeDelta small = TimeDelta::Millis(kSmall);
+ 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(small, TimeDelta::ms(kSmall));
- EXPECT_LE(small, TimeDelta::ms(kSmall));
- EXPECT_GE(small, TimeDelta::ms(kSmall));
- EXPECT_NE(small, TimeDelta::ms(kLarge));
- EXPECT_LE(small, TimeDelta::ms(kLarge));
- EXPECT_LT(small, TimeDelta::ms(kLarge));
- EXPECT_GE(large, TimeDelta::ms(kSmall));
- EXPECT_GT(large, TimeDelta::ms(kSmall));
+ EXPECT_EQ(small, TimeDelta::Millis(kSmall));
+ EXPECT_LE(small, TimeDelta::Millis(kSmall));
+ EXPECT_GE(small, TimeDelta::Millis(kSmall));
+ EXPECT_NE(small, TimeDelta::Millis(kLarge));
+ EXPECT_LE(small, TimeDelta::Millis(kLarge));
+ EXPECT_LT(small, TimeDelta::Millis(kLarge));
+ EXPECT_GE(large, TimeDelta::Millis(kSmall));
+ EXPECT_GT(large, TimeDelta::Millis(kSmall));
EXPECT_LT(TimeDelta::Zero(), small);
- EXPECT_GT(TimeDelta::Zero(), TimeDelta::ms(-kSmall));
- EXPECT_GT(TimeDelta::Zero(), TimeDelta::ms(-kSmall));
+ EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
+ EXPECT_GT(TimeDelta::Zero(), TimeDelta::Millis(-kSmall));
EXPECT_GT(TimeDelta::PlusInfinity(), large);
EXPECT_LT(TimeDelta::MinusInfinity(), TimeDelta::Zero());
}
TEST(TimeDeltaTest, Clamping) {
- const TimeDelta upper = TimeDelta::ms(800);
- const TimeDelta lower = TimeDelta::ms(100);
- const TimeDelta under = TimeDelta::ms(100);
- const TimeDelta inside = TimeDelta::ms(500);
- const TimeDelta over = TimeDelta::ms(1000);
+ const TimeDelta upper = TimeDelta::Millis(800);
+ const TimeDelta lower = TimeDelta::Millis(100);
+ const TimeDelta under = TimeDelta::Millis(100);
+ const TimeDelta inside = TimeDelta::Millis(500);
+ const TimeDelta over = TimeDelta::Millis(1000);
EXPECT_EQ(under.Clamped(lower, upper), lower);
EXPECT_EQ(inside.Clamped(lower, upper), inside);
EXPECT_EQ(over.Clamped(lower, upper), upper);
@@ -131,9 +131,10 @@
TEST(TimeDeltaTest, CanBeInititializedFromLargeInt) {
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);
- 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) {
@@ -143,16 +144,16 @@
const double kMillisDouble = kMicros * 1e-3;
const double kSecondsDouble = kMillisDouble * 1e-3;
- EXPECT_EQ(TimeDelta::us(kMicros).seconds<double>(), kSecondsDouble);
- EXPECT_EQ(TimeDelta::seconds(kSecondsDouble).us(), kMicros);
+ EXPECT_EQ(TimeDelta::Micros(kMicros).seconds<double>(), kSecondsDouble);
+ EXPECT_EQ(TimeDelta::Seconds(kSecondsDouble).us(), kMicros);
- EXPECT_EQ(TimeDelta::us(kMicros).ms<double>(), kMillisDouble);
- EXPECT_EQ(TimeDelta::ms(kMillisDouble).us(), kMicros);
+ EXPECT_EQ(TimeDelta::Micros(kMicros).ms<double>(), kMillisDouble);
+ EXPECT_EQ(TimeDelta::Millis(kMillisDouble).us(), kMicros);
- EXPECT_EQ(TimeDelta::us(kMicros).us<double>(), kMicrosDouble);
- EXPECT_EQ(TimeDelta::us(kMicrosDouble).us(), kMicros);
+ EXPECT_EQ(TimeDelta::Micros(kMicros).us<double>(), kMicrosDouble);
+ 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 kMinusInfinity = -kPlusInfinity;
@@ -166,44 +167,46 @@
EXPECT_EQ(TimeDelta::PlusInfinity().ns<double>(), kPlusInfinity);
EXPECT_EQ(TimeDelta::MinusInfinity().ns<double>(), kMinusInfinity);
- EXPECT_TRUE(TimeDelta::seconds(kPlusInfinity).IsPlusInfinity());
- EXPECT_TRUE(TimeDelta::seconds(kMinusInfinity).IsMinusInfinity());
- EXPECT_TRUE(TimeDelta::ms(kPlusInfinity).IsPlusInfinity());
- EXPECT_TRUE(TimeDelta::ms(kMinusInfinity).IsMinusInfinity());
- EXPECT_TRUE(TimeDelta::us(kPlusInfinity).IsPlusInfinity());
- EXPECT_TRUE(TimeDelta::us(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(TimeDelta::Seconds(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(TimeDelta::Seconds(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(TimeDelta::Millis(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(TimeDelta::Millis(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(TimeDelta::Micros(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(TimeDelta::Micros(kMinusInfinity).IsMinusInfinity());
}
TEST(TimeDeltaTest, MathOperations) {
const int64_t kValueA = 267;
const int64_t kValueB = 450;
- const TimeDelta delta_a = TimeDelta::ms(kValueA);
- const TimeDelta delta_b = TimeDelta::ms(kValueB);
+ const TimeDelta delta_a = TimeDelta::Millis(kValueA);
+ 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);
const int32_t kInt32Value = 123;
const double kFloatValue = 123.0;
- EXPECT_EQ((TimeDelta::us(kValueA) * kValueB).us(), kValueA * kValueB);
- EXPECT_EQ((TimeDelta::us(kValueA) * kInt32Value).us(), kValueA * kInt32Value);
- EXPECT_EQ((TimeDelta::us(kValueA) * kFloatValue).us(), kValueA * kFloatValue);
+ EXPECT_EQ((TimeDelta::Micros(kValueA) * kValueB).us(), kValueA * kValueB);
+ EXPECT_EQ((TimeDelta::Micros(kValueA) * kInt32Value).us(),
+ kValueA * kInt32Value);
+ EXPECT_EQ((TimeDelta::Micros(kValueA) * kFloatValue).us(),
+ kValueA * kFloatValue);
EXPECT_EQ((delta_b / 10).ms(), kValueB / 10);
EXPECT_EQ(delta_b / delta_a, static_cast<double>(kValueB) / kValueA);
- EXPECT_EQ(TimeDelta::us(-kValueA).Abs().us(), kValueA);
- EXPECT_EQ(TimeDelta::us(kValueA).Abs().us(), kValueA);
+ EXPECT_EQ(TimeDelta::Micros(-kValueA).Abs().us(), kValueA);
+ EXPECT_EQ(TimeDelta::Micros(kValueA).Abs().us(), kValueA);
- TimeDelta mutable_delta = TimeDelta::ms(kValueA);
- mutable_delta += TimeDelta::ms(kValueB);
- EXPECT_EQ(mutable_delta, TimeDelta::ms(kValueA + kValueB));
- mutable_delta -= TimeDelta::ms(kValueB);
- EXPECT_EQ(mutable_delta, TimeDelta::ms(kValueA));
+ TimeDelta mutable_delta = TimeDelta::Millis(kValueA);
+ mutable_delta += TimeDelta::Millis(kValueB);
+ EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA + kValueB));
+ mutable_delta -= TimeDelta::Millis(kValueB);
+ EXPECT_EQ(mutable_delta, TimeDelta::Millis(kValueA));
}
TEST(TimeDeltaTest, InfinityOperations) {
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((finite + TimeDelta::PlusInfinity()).IsPlusInfinity());
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index f9ed408..f71edfc 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -28,8 +28,26 @@
// difference of two Timestamps results in a TimeDelta.
class Timestamp final : public rtc_units_impl::UnitBase<Timestamp> {
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;
+ // TODO(danilchap): Migrate all code to the 3 factories above and delete the
+ // 6 factories below.
template <int64_t seconds>
static constexpr Timestamp Seconds() {
return FromFraction(1'000'000, seconds);
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index 6c2d1ee..43b2985 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -8,6 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
+#include <limits>
+
#include "api/units/timestamp.h"
#include "test/gtest.h"
@@ -19,9 +21,9 @@
static_assert(kTimestampInf.IsInfinite(), "");
static_assert(kTimestampInf.ms_or(-1) == -1, "");
- constexpr Timestamp kTimestampSeconds = Timestamp::Seconds<kValue>();
- constexpr Timestamp kTimestampMs = Timestamp::Millis<kValue>();
- constexpr Timestamp kTimestampUs = Timestamp::Micros<kValue>();
+ constexpr Timestamp kTimestampSeconds = Timestamp::Seconds(kValue);
+ constexpr Timestamp kTimestampMs = Timestamp::Millis(kValue);
+ constexpr Timestamp kTimestampUs = Timestamp::Micros(kValue);
static_assert(kTimestampSeconds.seconds_or(0) == kValue, "");
static_assert(kTimestampMs.ms_or(0) == kValue, "");
@@ -36,20 +38,20 @@
TEST(TimestampTest, GetBackSameValues) {
const int64_t kValue = 499;
- EXPECT_EQ(Timestamp::ms(kValue).ms(), kValue);
- EXPECT_EQ(Timestamp::us(kValue).us(), kValue);
- EXPECT_EQ(Timestamp::seconds(kValue).seconds(), kValue);
+ EXPECT_EQ(Timestamp::Millis(kValue).ms(), kValue);
+ EXPECT_EQ(Timestamp::Micros(kValue).us(), kValue);
+ EXPECT_EQ(Timestamp::Seconds(kValue).seconds(), kValue);
}
TEST(TimestampTest, GetDifferentPrefix) {
const int64_t kValue = 3000000;
- EXPECT_EQ(Timestamp::us(kValue).seconds(), kValue / 1000000);
- EXPECT_EQ(Timestamp::ms(kValue).seconds(), kValue / 1000);
- EXPECT_EQ(Timestamp::us(kValue).ms(), kValue / 1000);
+ EXPECT_EQ(Timestamp::Micros(kValue).seconds(), kValue / 1000000);
+ EXPECT_EQ(Timestamp::Millis(kValue).seconds(), kValue / 1000);
+ EXPECT_EQ(Timestamp::Micros(kValue).ms(), kValue / 1000);
- EXPECT_EQ(Timestamp::ms(kValue).us(), kValue * 1000);
- EXPECT_EQ(Timestamp::seconds(kValue).ms(), kValue * 1000);
- EXPECT_EQ(Timestamp::seconds(kValue).us(), kValue * 1000000);
+ EXPECT_EQ(Timestamp::Millis(kValue).us(), kValue * 1000);
+ EXPECT_EQ(Timestamp::Seconds(kValue).ms(), kValue * 1000);
+ EXPECT_EQ(Timestamp::Seconds(kValue).us(), kValue * 1000000);
}
TEST(TimestampTest, IdentityChecks) {
@@ -57,11 +59,11 @@
EXPECT_TRUE(Timestamp::PlusInfinity().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::MinusInfinity().IsFinite());
- EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
+ EXPECT_TRUE(Timestamp::Millis(kValue).IsFinite());
EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
@@ -76,22 +78,23 @@
EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
- EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge));
- EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
- EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
- EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
- EXPECT_NE(Timestamp::ms(kSmall), Timestamp::ms(kLarge));
- EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kLarge));
- EXPECT_LT(Timestamp::ms(kSmall), Timestamp::ms(kLarge));
- EXPECT_GE(Timestamp::ms(kLarge), Timestamp::ms(kSmall));
- EXPECT_GT(Timestamp::ms(kLarge), Timestamp::ms(kSmall));
+ EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::Millis(kLarge));
+ EXPECT_EQ(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
+ EXPECT_LE(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
+ EXPECT_GE(Timestamp::Millis(kSmall), Timestamp::Millis(kSmall));
+ EXPECT_NE(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
+ EXPECT_LE(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
+ EXPECT_LT(Timestamp::Millis(kSmall), Timestamp::Millis(kLarge));
+ EXPECT_GE(Timestamp::Millis(kLarge), Timestamp::Millis(kSmall));
+ EXPECT_GT(Timestamp::Millis(kLarge), Timestamp::Millis(kSmall));
}
TEST(TimestampTest, CanBeInititializedFromLargeInt) {
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);
- 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) {
@@ -100,14 +103,14 @@
const double kMillisDouble = kMicros * 1e-3;
const double kSecondsDouble = kMillisDouble * 1e-3;
- EXPECT_EQ(Timestamp::us(kMicros).seconds<double>(), kSecondsDouble);
- EXPECT_EQ(Timestamp::seconds(kSecondsDouble).us(), kMicros);
+ EXPECT_EQ(Timestamp::Micros(kMicros).seconds<double>(), kSecondsDouble);
+ EXPECT_EQ(Timestamp::Seconds(kSecondsDouble).us(), kMicros);
- EXPECT_EQ(Timestamp::us(kMicros).ms<double>(), kMillisDouble);
- EXPECT_EQ(Timestamp::ms(kMillisDouble).us(), kMicros);
+ EXPECT_EQ(Timestamp::Micros(kMicros).ms<double>(), kMillisDouble);
+ EXPECT_EQ(Timestamp::Millis(kMillisDouble).us(), kMicros);
- EXPECT_EQ(Timestamp::us(kMicros).us<double>(), kMicrosDouble);
- EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
+ EXPECT_EQ(Timestamp::Micros(kMicros).us<double>(), kMicrosDouble);
+ EXPECT_EQ(Timestamp::Micros(kMicrosDouble).us(), kMicros);
const double kPlusInfinity = std::numeric_limits<double>::infinity();
const double kMinusInfinity = -kPlusInfinity;
@@ -119,25 +122,25 @@
EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
- EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity());
- EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity());
- EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity());
- EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity());
- EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity());
- EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(Timestamp::Seconds(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(Timestamp::Seconds(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(Timestamp::Millis(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(Timestamp::Millis(kMinusInfinity).IsMinusInfinity());
+ EXPECT_TRUE(Timestamp::Micros(kPlusInfinity).IsPlusInfinity());
+ EXPECT_TRUE(Timestamp::Micros(kMinusInfinity).IsMinusInfinity());
}
TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
const int64_t kValueA = 267;
const int64_t kValueB = 450;
- const Timestamp time_a = Timestamp::ms(kValueA);
- const Timestamp time_b = Timestamp::ms(kValueB);
- const TimeDelta delta_a = TimeDelta::ms(kValueA);
- const TimeDelta delta_b = TimeDelta::ms(kValueB);
+ const Timestamp time_a = Timestamp::Millis(kValueA);
+ const Timestamp time_b = Timestamp::Millis(kValueB);
+ const TimeDelta delta_a = TimeDelta::Millis(kValueA);
+ const TimeDelta delta_b = TimeDelta::Millis(kValueB);
- EXPECT_EQ((time_a - time_b), TimeDelta::ms(kValueA - kValueB));
- EXPECT_EQ((time_b - delta_a), Timestamp::ms(kValueB - kValueA));
- EXPECT_EQ((time_b + delta_a), Timestamp::ms(kValueB + kValueA));
+ EXPECT_EQ((time_a - time_b), TimeDelta::Millis(kValueA - kValueB));
+ EXPECT_EQ((time_b - delta_a), Timestamp::Millis(kValueB - kValueA));
+ EXPECT_EQ((time_b + delta_a), Timestamp::Millis(kValueB + kValueA));
Timestamp mutable_time = time_a;
mutable_time += delta_b;
@@ -148,8 +151,8 @@
TEST(UnitConversionTest, InfinityOperations) {
const int64_t kValue = 267;
- const Timestamp finite_time = Timestamp::ms(kValue);
- const TimeDelta finite_delta = TimeDelta::ms(kValue);
+ const Timestamp finite_time = Timestamp::Millis(kValue);
+ const TimeDelta finite_delta = TimeDelta::Millis(kValue);
EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());