data_rate_unittest.cc (7965B)
1 /* 2 * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "api/units/data_rate.h" 12 13 #include <cstdint> 14 #include <limits> 15 16 #include "api/units/data_size.h" 17 #include "api/units/frequency.h" 18 #include "api/units/time_delta.h" 19 #include "rtc_base/checks.h" 20 #include "rtc_base/logging.h" 21 #include "test/gtest.h" 22 23 namespace webrtc { 24 namespace test { 25 26 TEST(DataRateTest, CompilesWithChecksAndLogs) { 27 DataRate a = DataRate::KilobitsPerSec(300); 28 DataRate b = DataRate::KilobitsPerSec(210); 29 RTC_CHECK_GT(a, b); 30 RTC_LOG(LS_INFO) << a; 31 } 32 33 TEST(DataRateTest, ConstExpr) { 34 constexpr int64_t kValue = 12345; 35 constexpr DataRate kDataRateZero = DataRate::Zero(); 36 constexpr DataRate kDataRateInf = DataRate::Infinity(); 37 static_assert(DataRate() == kDataRateZero); 38 static_assert(kDataRateZero.IsZero(), ""); 39 static_assert(kDataRateInf.IsInfinite(), ""); 40 static_assert(kDataRateInf.bps_or(-1) == -1, ""); 41 static_assert(kDataRateInf > kDataRateZero, ""); 42 43 constexpr DataRate kDataRateBps = DataRate::BitsPerSec(kValue); 44 constexpr DataRate kDataRateKbps = DataRate::KilobitsPerSec(kValue); 45 static_assert(kDataRateBps.bps<double>() == kValue, ""); 46 static_assert(kDataRateBps.bps_or(0) == kValue, ""); 47 static_assert(kDataRateKbps.kbps_or(0) == kValue, ""); 48 } 49 50 TEST(DataRateTest, GetBackSameValues) { 51 const int64_t kValue = 123 * 8; 52 EXPECT_EQ(DataRate::BitsPerSec(kValue).bps(), kValue); 53 EXPECT_EQ(DataRate::KilobitsPerSec(kValue).kbps(), kValue); 54 } 55 56 TEST(DataRateTest, GetDifferentPrefix) { 57 const int64_t kValue = 123 * 8000; 58 EXPECT_EQ(DataRate::BitsPerSec(kValue).kbps(), kValue / 1000); 59 } 60 61 TEST(DataRateTest, IdentityChecks) { 62 const int64_t kValue = 3000; 63 EXPECT_TRUE(DataRate::Zero().IsZero()); 64 EXPECT_FALSE(DataRate::BitsPerSec(kValue).IsZero()); 65 66 EXPECT_TRUE(DataRate::Infinity().IsInfinite()); 67 EXPECT_FALSE(DataRate::Zero().IsInfinite()); 68 EXPECT_FALSE(DataRate::BitsPerSec(kValue).IsInfinite()); 69 70 EXPECT_FALSE(DataRate::Infinity().IsFinite()); 71 EXPECT_TRUE(DataRate::BitsPerSec(kValue).IsFinite()); 72 EXPECT_TRUE(DataRate::Zero().IsFinite()); 73 } 74 75 TEST(DataRateTest, ComparisonOperators) { 76 const int64_t kSmall = 450; 77 const int64_t kLarge = 451; 78 const DataRate small = DataRate::BitsPerSec(kSmall); 79 const DataRate large = DataRate::BitsPerSec(kLarge); 80 81 EXPECT_EQ(DataRate::Zero(), DataRate::BitsPerSec(0)); 82 EXPECT_EQ(DataRate::Infinity(), DataRate::Infinity()); 83 EXPECT_EQ(small, small); 84 EXPECT_LE(small, small); 85 EXPECT_GE(small, small); 86 EXPECT_NE(small, large); 87 EXPECT_LE(small, large); 88 EXPECT_LT(small, large); 89 EXPECT_GE(large, small); 90 EXPECT_GT(large, small); 91 EXPECT_LT(DataRate::Zero(), small); 92 EXPECT_GT(DataRate::Infinity(), large); 93 } 94 95 TEST(DataRateTest, ConvertsToAndFromDouble) { 96 const int64_t kValue = 128; 97 const double kDoubleValue = static_cast<double>(kValue); 98 const double kDoubleKbps = kValue * 1e-3; 99 const double kFloatKbps = static_cast<float>(kDoubleKbps); 100 101 EXPECT_EQ(DataRate::BitsPerSec(kValue).bps<double>(), kDoubleValue); 102 EXPECT_EQ(DataRate::BitsPerSec(kValue).kbps<double>(), kDoubleKbps); 103 EXPECT_EQ(DataRate::BitsPerSec(kValue).kbps<float>(), kFloatKbps); 104 EXPECT_EQ(DataRate::BitsPerSec(kDoubleValue).bps(), kValue); 105 EXPECT_EQ(DataRate::KilobitsPerSec(kDoubleKbps).bps(), kValue); 106 107 const double kInfinity = std::numeric_limits<double>::infinity(); 108 EXPECT_EQ(DataRate::Infinity().bps<double>(), kInfinity); 109 EXPECT_TRUE(DataRate::BitsPerSec(kInfinity).IsInfinite()); 110 EXPECT_TRUE(DataRate::KilobitsPerSec(kInfinity).IsInfinite()); 111 } 112 TEST(DataRateTest, Clamping) { 113 const DataRate upper = DataRate::KilobitsPerSec(800); 114 const DataRate lower = DataRate::KilobitsPerSec(100); 115 const DataRate under = DataRate::KilobitsPerSec(100); 116 const DataRate inside = DataRate::KilobitsPerSec(500); 117 const DataRate over = DataRate::KilobitsPerSec(1000); 118 EXPECT_EQ(under.Clamped(lower, upper), lower); 119 EXPECT_EQ(inside.Clamped(lower, upper), inside); 120 EXPECT_EQ(over.Clamped(lower, upper), upper); 121 122 DataRate mutable_rate = lower; 123 mutable_rate.Clamp(lower, upper); 124 EXPECT_EQ(mutable_rate, lower); 125 mutable_rate = inside; 126 mutable_rate.Clamp(lower, upper); 127 EXPECT_EQ(mutable_rate, inside); 128 mutable_rate = over; 129 mutable_rate.Clamp(lower, upper); 130 EXPECT_EQ(mutable_rate, upper); 131 } 132 133 TEST(DataRateTest, MathOperations) { 134 const int64_t kValueA = 450; 135 const int64_t kValueB = 267; 136 const DataRate rate_a = DataRate::BitsPerSec(kValueA); 137 const DataRate rate_b = DataRate::BitsPerSec(kValueB); 138 const int32_t kInt32Value = 123; 139 const double kFloatValue = 123.0; 140 141 EXPECT_EQ((rate_a + rate_b).bps(), kValueA + kValueB); 142 EXPECT_EQ((rate_a - rate_b).bps(), kValueA - kValueB); 143 144 EXPECT_EQ((rate_a * kValueB).bps(), kValueA * kValueB); 145 EXPECT_EQ((rate_a * kInt32Value).bps(), kValueA * kInt32Value); 146 EXPECT_EQ((rate_a * kFloatValue).bps(), kValueA * kFloatValue); 147 148 EXPECT_EQ(rate_a / rate_b, static_cast<double>(kValueA) / kValueB); 149 150 EXPECT_EQ((rate_a / 10).bps(), kValueA / 10); 151 EXPECT_NEAR((rate_a / 0.5).bps(), kValueA * 2, 1); 152 153 DataRate mutable_rate = DataRate::BitsPerSec(kValueA); 154 mutable_rate += rate_b; 155 EXPECT_EQ(mutable_rate.bps(), kValueA + kValueB); 156 mutable_rate -= rate_a; 157 EXPECT_EQ(mutable_rate.bps(), kValueB); 158 } 159 160 TEST(UnitConversionTest, DataRateAndDataSizeAndTimeDelta) { 161 const int64_t kSeconds = 5; 162 const int64_t kBitsPerSecond = 440; 163 const int64_t kBytes = 44000; 164 const TimeDelta delta_a = TimeDelta::Seconds(kSeconds); 165 const DataRate rate_b = DataRate::BitsPerSec(kBitsPerSecond); 166 const DataSize size_c = DataSize::Bytes(kBytes); 167 EXPECT_EQ((delta_a * rate_b).bytes(), kSeconds * kBitsPerSecond / 8); 168 EXPECT_EQ((rate_b * delta_a).bytes(), kSeconds * kBitsPerSecond / 8); 169 EXPECT_EQ((size_c / delta_a).bps(), kBytes * 8 / kSeconds); 170 EXPECT_EQ((size_c / rate_b).seconds(), kBytes * 8 / kBitsPerSecond); 171 } 172 173 TEST(UnitConversionTest, DataRateAndDataSizeAndFrequency) { 174 const int64_t kHertz = 30; 175 const int64_t kBitsPerSecond = 96000; 176 const int64_t kBytes = 1200; 177 const Frequency freq_a = Frequency::Hertz(kHertz); 178 const DataRate rate_b = DataRate::BitsPerSec(kBitsPerSecond); 179 const DataSize size_c = DataSize::Bytes(kBytes); 180 EXPECT_EQ((freq_a * size_c).bps(), kHertz * kBytes * 8); 181 EXPECT_EQ((size_c * freq_a).bps(), kHertz * kBytes * 8); 182 EXPECT_EQ((rate_b / size_c).hertz<int64_t>(), kBitsPerSecond / kBytes / 8); 183 EXPECT_EQ((rate_b / freq_a).bytes(), kBitsPerSecond / kHertz / 8); 184 } 185 186 TEST(UnitConversionDeathTest, DivisionFailsOnLargeSize) { 187 // Note that the failure is expected since the current implementation is 188 // implementated in a way that does not support division of large sizes. If 189 // the implementation is changed, this test can safely be removed. 190 const int64_t kJustSmallEnoughForDivision = 191 std::numeric_limits<int64_t>::max() / 8000000; 192 const DataSize large_size = DataSize::Bytes(kJustSmallEnoughForDivision); 193 const DataRate data_rate = DataRate::KilobitsPerSec(100); 194 const TimeDelta time_delta = TimeDelta::Millis(100); 195 EXPECT_TRUE((large_size / data_rate).IsFinite()); 196 EXPECT_TRUE((large_size / time_delta).IsFinite()); 197 #if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) && RTC_DCHECK_IS_ON 198 const int64_t kToolargeForDivision = kJustSmallEnoughForDivision + 1; 199 const DataSize too_large_size = DataSize::Bytes(kToolargeForDivision); 200 EXPECT_DEATH(too_large_size / data_rate, ""); 201 EXPECT_DEATH(too_large_size / time_delta, ""); 202 #endif // GTEST_HAS_DEATH_TEST && !!defined(WEBRTC_ANDROID) && RTC_DCHECK_IS_ON 203 } 204 } // namespace test 205 } // namespace webrtc