Add DataSize and DataRate factories
Bug: webrtc:9709
Change-Id: I8a3af8c62f7ed52de84efb8b1306701fa2e40278
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168606
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30533}
diff --git a/api/units/data_rate_unittest.cc b/api/units/data_rate_unittest.cc
index 80b9f7b..4a6dd21 100644
--- a/api/units/data_rate_unittest.cc
+++ b/api/units/data_rate_unittest.cc
@@ -17,8 +17,8 @@
namespace test {
TEST(DataRateTest, CompilesWithChecksAndLogs) {
- DataRate a = DataRate::kbps(300);
- DataRate b = DataRate::kbps(210);
+ DataRate a = DataRate::KilobitsPerSec(300);
+ DataRate b = DataRate::KilobitsPerSec(210);
RTC_CHECK_GT(a, b);
RTC_LOG(LS_INFO) << a;
}
@@ -32,8 +32,8 @@
static_assert(kDataRateInf.bps_or(-1) == -1, "");
static_assert(kDataRateInf > kDataRateZero, "");
- constexpr DataRate kDataRateBps = DataRate::BitsPerSec<kValue>();
- constexpr DataRate kDataRateKbps = DataRate::KilobitsPerSec<kValue>();
+ constexpr DataRate kDataRateBps = DataRate::BitsPerSec(kValue);
+ constexpr DataRate kDataRateKbps = DataRate::KilobitsPerSec(kValue);
static_assert(kDataRateBps.bps<double>() == kValue, "");
static_assert(kDataRateBps.bps_or(0) == kValue, "");
static_assert(kDataRateKbps.kbps_or(0) == kValue, "");
@@ -41,36 +41,36 @@
TEST(DataRateTest, GetBackSameValues) {
const int64_t kValue = 123 * 8;
- EXPECT_EQ(DataRate::bps(kValue).bps(), kValue);
- EXPECT_EQ(DataRate::kbps(kValue).kbps(), kValue);
+ EXPECT_EQ(DataRate::BitsPerSec(kValue).bps(), kValue);
+ EXPECT_EQ(DataRate::KilobitsPerSec(kValue).kbps(), kValue);
}
TEST(DataRateTest, GetDifferentPrefix) {
const int64_t kValue = 123 * 8000;
- EXPECT_EQ(DataRate::bps(kValue).kbps(), kValue / 1000);
+ EXPECT_EQ(DataRate::BitsPerSec(kValue).kbps(), kValue / 1000);
}
TEST(DataRateTest, IdentityChecks) {
const int64_t kValue = 3000;
EXPECT_TRUE(DataRate::Zero().IsZero());
- EXPECT_FALSE(DataRate::bps(kValue).IsZero());
+ EXPECT_FALSE(DataRate::BitsPerSec(kValue).IsZero());
EXPECT_TRUE(DataRate::Infinity().IsInfinite());
EXPECT_FALSE(DataRate::Zero().IsInfinite());
- EXPECT_FALSE(DataRate::bps(kValue).IsInfinite());
+ EXPECT_FALSE(DataRate::BitsPerSec(kValue).IsInfinite());
EXPECT_FALSE(DataRate::Infinity().IsFinite());
- EXPECT_TRUE(DataRate::bps(kValue).IsFinite());
+ EXPECT_TRUE(DataRate::BitsPerSec(kValue).IsFinite());
EXPECT_TRUE(DataRate::Zero().IsFinite());
}
TEST(DataRateTest, ComparisonOperators) {
const int64_t kSmall = 450;
const int64_t kLarge = 451;
- const DataRate small = DataRate::bps(kSmall);
- const DataRate large = DataRate::bps(kLarge);
+ const DataRate small = DataRate::BitsPerSec(kSmall);
+ const DataRate large = DataRate::BitsPerSec(kLarge);
- EXPECT_EQ(DataRate::Zero(), DataRate::bps(0));
+ EXPECT_EQ(DataRate::Zero(), DataRate::BitsPerSec(0));
EXPECT_EQ(DataRate::Infinity(), DataRate::Infinity());
EXPECT_EQ(small, small);
EXPECT_LE(small, small);
@@ -90,23 +90,23 @@
const double kDoubleKbps = kValue * 1e-3;
const double kFloatKbps = static_cast<float>(kDoubleKbps);
- EXPECT_EQ(DataRate::bps(kValue).bps<double>(), kDoubleValue);
- EXPECT_EQ(DataRate::bps(kValue).kbps<double>(), kDoubleKbps);
- EXPECT_EQ(DataRate::bps(kValue).kbps<float>(), kFloatKbps);
- EXPECT_EQ(DataRate::bps(kDoubleValue).bps(), kValue);
- EXPECT_EQ(DataRate::kbps(kDoubleKbps).bps(), kValue);
+ EXPECT_EQ(DataRate::BitsPerSec(kValue).bps<double>(), kDoubleValue);
+ EXPECT_EQ(DataRate::BitsPerSec(kValue).kbps<double>(), kDoubleKbps);
+ EXPECT_EQ(DataRate::BitsPerSec(kValue).kbps<float>(), kFloatKbps);
+ EXPECT_EQ(DataRate::BitsPerSec(kDoubleValue).bps(), kValue);
+ EXPECT_EQ(DataRate::KilobitsPerSec(kDoubleKbps).bps(), kValue);
const double kInfinity = std::numeric_limits<double>::infinity();
EXPECT_EQ(DataRate::Infinity().bps<double>(), kInfinity);
- EXPECT_TRUE(DataRate::bps(kInfinity).IsInfinite());
- EXPECT_TRUE(DataRate::kbps(kInfinity).IsInfinite());
+ EXPECT_TRUE(DataRate::BitsPerSec(kInfinity).IsInfinite());
+ EXPECT_TRUE(DataRate::KilobitsPerSec(kInfinity).IsInfinite());
}
TEST(DataRateTest, Clamping) {
- const DataRate upper = DataRate::kbps(800);
- const DataRate lower = DataRate::kbps(100);
- const DataRate under = DataRate::kbps(100);
- const DataRate inside = DataRate::kbps(500);
- const DataRate over = DataRate::kbps(1000);
+ const DataRate upper = DataRate::KilobitsPerSec(800);
+ const DataRate lower = DataRate::KilobitsPerSec(100);
+ const DataRate under = DataRate::KilobitsPerSec(100);
+ const DataRate inside = DataRate::KilobitsPerSec(500);
+ const DataRate over = DataRate::KilobitsPerSec(1000);
EXPECT_EQ(under.Clamped(lower, upper), lower);
EXPECT_EQ(inside.Clamped(lower, upper), inside);
EXPECT_EQ(over.Clamped(lower, upper), upper);
@@ -125,8 +125,8 @@
TEST(DataRateTest, MathOperations) {
const int64_t kValueA = 450;
const int64_t kValueB = 267;
- const DataRate rate_a = DataRate::bps(kValueA);
- const DataRate rate_b = DataRate::bps(kValueB);
+ const DataRate rate_a = DataRate::BitsPerSec(kValueA);
+ const DataRate rate_b = DataRate::BitsPerSec(kValueB);
const int32_t kInt32Value = 123;
const double kFloatValue = 123.0;
@@ -142,7 +142,7 @@
EXPECT_EQ((rate_a / 10).bps(), kValueA / 10);
EXPECT_NEAR((rate_a / 0.5).bps(), kValueA * 2, 1);
- DataRate mutable_rate = DataRate::bps(kValueA);
+ DataRate mutable_rate = DataRate::BitsPerSec(kValueA);
mutable_rate += rate_b;
EXPECT_EQ(mutable_rate.bps(), kValueA + kValueB);
mutable_rate -= rate_a;
@@ -154,8 +154,8 @@
const int64_t kBitsPerSecond = 440;
const int64_t kBytes = 44000;
const TimeDelta delta_a = TimeDelta::Seconds(kSeconds);
- const DataRate rate_b = DataRate::bps(kBitsPerSecond);
- const DataSize size_c = DataSize::bytes(kBytes);
+ const DataRate rate_b = DataRate::BitsPerSec(kBitsPerSecond);
+ const DataSize size_c = DataSize::Bytes(kBytes);
EXPECT_EQ((delta_a * rate_b).bytes(), kSeconds * kBitsPerSecond / 8);
EXPECT_EQ((rate_b * delta_a).bytes(), kSeconds * kBitsPerSecond / 8);
EXPECT_EQ((size_c / delta_a).bps(), kBytes * 8 / kSeconds);
@@ -167,8 +167,8 @@
const int64_t kBitsPerSecond = 96000;
const int64_t kBytes = 1200;
const Frequency freq_a = Frequency::Hertz(kHertz);
- const DataRate rate_b = DataRate::bps(kBitsPerSecond);
- const DataSize size_c = DataSize::bytes(kBytes);
+ const DataRate rate_b = DataRate::BitsPerSec(kBitsPerSecond);
+ const DataSize size_c = DataSize::Bytes(kBytes);
EXPECT_EQ((freq_a * size_c).bps(), kHertz * kBytes * 8);
EXPECT_EQ((size_c * freq_a).bps(), kHertz * kBytes * 8);
EXPECT_EQ((rate_b / size_c).hertz<int64_t>(), kBitsPerSecond / kBytes / 8);
@@ -181,14 +181,14 @@
// the implementation is changed, this test can safely be removed.
const int64_t kJustSmallEnoughForDivision =
std::numeric_limits<int64_t>::max() / 8000000;
- const DataSize large_size = DataSize::bytes(kJustSmallEnoughForDivision);
- const DataRate data_rate = DataRate::kbps(100);
+ const DataSize large_size = DataSize::Bytes(kJustSmallEnoughForDivision);
+ const DataRate data_rate = DataRate::KilobitsPerSec(100);
const TimeDelta time_delta = TimeDelta::Millis(100);
EXPECT_TRUE((large_size / data_rate).IsFinite());
EXPECT_TRUE((large_size / time_delta).IsFinite());
#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) && RTC_DCHECK_IS_ON
const int64_t kToolargeForDivision = kJustSmallEnoughForDivision + 1;
- const DataSize too_large_size = DataSize::bytes(kToolargeForDivision);
+ const DataSize too_large_size = DataSize::Bytes(kToolargeForDivision);
EXPECT_DEATH(too_large_size / data_rate, "");
EXPECT_DEATH(too_large_size / time_delta, "");
#endif // GTEST_HAS_DEATH_TEST && !!defined(WEBRTC_ANDROID) && RTC_DCHECK_IS_ON