zqz/platform-external-webrtc
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
Download Patch File Download Diff File Expand all files Collapse all files

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.
*/
#include <limits>
#include "api/units/timestamp.h"
#include "test/gtest.h"
@ -19,9 +21,9 @@ TEST(TimestampTest, ConstExpr) {
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, ConstExpr) {
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 @@ TEST(TimestampTest, IdentityChecks) {
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 @@ TEST(TimestampTest, ComparisonOperators) {
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 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
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 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
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, TimestampAndTimeDeltaMath) {
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());